1 /*

     2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.incubator.http;

    27 

    28 import java.io.IOException;

    29 import java.io.UncheckedIOException;

    30 import java.net.InetSocketAddress;

    31 import java.nio.ByteBuffer;

    32 import java.nio.channels.SocketChannel;

    33 import java.util.concurrent.CompletableFuture;

    34 import javax.net.ssl.SSLEngineResult.Status;

    35 import javax.net.ssl.SSLParameters;

    36 import jdk.incubator.http.SSLDelegate.WrapperResult;

    37 

    38 import jdk.incubator.http.internal.common.ByteBufferReference;

    39 import jdk.incubator.http.internal.common.Utils;

    40 

    41 /**

    42  * An SSL tunnel built on a Plain (CONNECT) TCP tunnel.

    43  */

    44 class SSLTunnelConnection extends HttpConnection {

    45 

    46     final PlainTunnelingConnection delegate;

    47     protected SSLDelegate sslDelegate;

    48     private volatile boolean connected;

    49     final String serverName;

    50 

    51     @Override

    52     public void connect() throws IOException, InterruptedException {

    53         delegate.connect();

    54         this.sslDelegate = new SSLDelegate(delegate.channel(), client, null, serverName);

    55         connected = true;

    56     }

    57 

    58     @Override

    59     boolean connected() {

    60         return connected && delegate.connected();

    61     }

    62 

    63     @Override

    64     public CompletableFuture<Void> connectAsync() {

    65         return delegate.connectAsync()

    66             .thenAccept((Void v) -> {

    67                 try {

    68                     // can this block?

    69                     this.sslDelegate = new SSLDelegate(delegate.channel(),

    70                                                        client,

    71                                                        null, serverName);

    72                     connected = true;

    73                 } catch (IOException e) {

    74                     throw new UncheckedIOException(e);

    75                 }

    76             });

    77     }

    78 

    79     SSLTunnelConnection(InetSocketAddress addr,

    80                         HttpClientImpl client,

    81                         InetSocketAddress proxy)

    82     {

    83         super(addr, client);

    84         this.serverName = Utils.getServerName(addr);

    85         delegate = new PlainTunnelingConnection(addr, proxy, client);

    86     }

    87 

    88     /**

    89      * Create an SSLTunnelConnection from an existing connected AsyncSSLTunnelConnection.

    90      * Used when downgrading from HTTP/2 to HTTP/1.1

    91      */

    92     SSLTunnelConnection(AsyncSSLTunnelConnection c) {

    93         super(c.address, c.client);

    94         this.delegate = c.plainConnection();

    95         AsyncSSLDelegate adel = c.sslDelegate();

    96         this.sslDelegate = new SSLDelegate(adel.engine, delegate.channel(), client, adel.serverName);

    97         this.serverName = adel.serverName;

    98         connected = c.connected();

    99     }

   100 

   101     @Override

   102     SSLParameters sslParameters() {

   103         return sslDelegate.getSSLParameters();

   104     }

   105 

   106     @Override

   107     public String toString() {

   108         return "SSLTunnelConnection: " + super.toString();

   109     }

   110 

   111     private static long countBytes(ByteBuffer[] buffers, int start, int number) {

   112         long c = 0;

   113         for (int i=0; i<number; i++) {

   114             c+= buffers[start+i].remaining();

   115         }

   116         return c;

   117     }

   118 

   119     @Override

   120     ConnectionPool.CacheKey cacheKey() {

   121         return ConnectionPool.cacheKey(address, delegate.proxyAddr);

   122     }

   123 

   124     @Override

   125     long write(ByteBuffer[] buffers, int start, int number) throws IOException {

   126         //debugPrint("Send", buffers, start, number);

   127         long l = countBytes(buffers, start, number);

   128         WrapperResult r = sslDelegate.sendData(buffers, start, number);

   129         if (r.result.getStatus() == Status.CLOSED) {

   130             if (l > 0) {

   131                 throw new IOException("SSLHttpConnection closed");

   132             }

   133         }

   134         return l;

   135     }

   136 

   137     @Override

   138     long write(ByteBuffer buffer) throws IOException {

   139         //debugPrint("Send", buffer);

   140         long l = buffer.remaining();

   141         WrapperResult r = sslDelegate.sendData(buffer);

   142         if (r.result.getStatus() == Status.CLOSED) {

   143             if (l > 0) {

   144                 throw new IOException("SSLHttpConnection closed");

   145             }

   146         }

   147         return l;

   148     }

   149 

   150     @Override

   151     void writeAsync(ByteBufferReference[] buffers) throws IOException {

   152         write(ByteBufferReference.toBuffers(buffers), 0, buffers.length);

   153     }

   154 

   155     @Override

   156     void writeAsyncUnordered(ByteBufferReference[] buffers) throws IOException {

   157         write(ByteBufferReference.toBuffers(buffers), 0, buffers.length);

   158     }

   159 

   160     @Override

   161     void flushAsync() throws IOException {

   162         // nothing to do

   163     }

   164 

   165     @Override

   166     public void close() {

   167         Utils.close(delegate.channel());

   168     }

   169 

   170     @Override

   171     void shutdownInput() throws IOException {

   172         delegate.channel().shutdownInput();

   173     }

   174 

   175     @Override

   176     void shutdownOutput() throws IOException {

   177         delegate.channel().shutdownOutput();

   178     }

   179 

   180     @Override

   181     protected ByteBuffer readImpl() throws IOException {

   182         ByteBuffer buf = Utils.getBuffer();

   183 

   184         WrapperResult r = sslDelegate.recvData(buf);

   185         return r.buf;

   186     }

   187 

   188     @Override

   189     SocketChannel channel() {

   190         return delegate.channel();

   191     }

   192 

   193     @Override

   194     CompletableFuture<Void> whenReceivingResponse() {

   195         return delegate.whenReceivingResponse();

   196     }

   197 

   198     @Override

   199     boolean isSecure() {

   200         return true;

   201     }

   202 

   203     @Override

   204     boolean isProxied() {

   205         return true;

   206     }

   207 }