1 /*

     2  * Copyright (c) 2015, 2018, 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 java.net.http.internal;

    27 

    28 import java.io.IOException;

    29 import java.net.URI;

    30 import java.nio.ByteBuffer;

    31 import java.util.Optional;

    32 import java.util.concurrent.CompletableFuture;

    33 import java.util.function.Supplier;

    34 import javax.net.ssl.SSLParameters;

    35 import java.net.http.HttpClient;

    36 import java.net.http.HttpHeaders;

    37 import java.net.http.HttpRequest;

    38 import java.net.http.HttpResponse;

    39 import java.net.http.internal.websocket.RawChannel;

    40 

    41 /**

    42  * The implementation class for HttpResponse

    43  */

    44 class HttpResponseImpl<T> extends HttpResponse<T> implements RawChannel.Provider {

    45 

    46     final int responseCode;

    47     final Exchange<T> exchange;

    48     final HttpRequest initialRequest;

    49     final Optional<HttpResponse<T>> previousResponse;

    50     final HttpHeaders headers;

    51     final SSLParameters sslParameters;

    52     final URI uri;

    53     final HttpClient.Version version;

    54     RawChannel rawchan;

    55     final HttpConnection connection;

    56     final Stream<T> stream;

    57     final T body;

    58 

    59     public HttpResponseImpl(HttpRequest initialRequest,

    60                             Response response,

    61                             HttpResponse<T> previousResponse,

    62                             T body,

    63                             Exchange<T> exch) {

    64         this.responseCode = response.statusCode();

    65         this.exchange = exch;

    66         this.initialRequest = initialRequest;

    67         this.previousResponse = Optional.ofNullable(previousResponse);

    68         this.headers = response.headers();

    69         //this.trailers = trailers;

    70         this.sslParameters = exch.client().sslParameters();

    71         this.uri = response.request().uri();

    72         this.version = response.version();

    73         this.connection = connection(exch);

    74         this.stream = null;

    75         this.body = body;

    76     }

    77 

    78     private HttpConnection connection(Exchange<?> exch) {

    79         if (exch == null || exch.exchImpl == null) {

    80             assert responseCode == 407;

    81             return null; // case of Proxy 407

    82         }

    83         return exch.exchImpl.connection();

    84     }

    85 

    86     private ExchangeImpl<?> exchangeImpl() {

    87         return exchange != null ? exchange.exchImpl : stream;

    88     }

    89 

    90     @Override

    91     public int statusCode() {

    92         return responseCode;

    93     }

    94 

    95     @Override

    96     public HttpRequest request() {

    97         return initialRequest;

    98     }

    99 

   100     @Override

   101     public Optional<HttpResponse<T>> previousResponse() {

   102         return previousResponse;

   103     }

   104 

   105     @Override

   106     public HttpHeaders headers() {

   107         return headers;

   108     }

   109 

   110     @Override

   111     public T body() {

   112         return body;

   113     }

   114 

   115     @Override

   116     public SSLParameters sslParameters() {

   117         return sslParameters;

   118     }

   119 

   120     @Override

   121     public URI uri() {

   122         return uri;

   123     }

   124 

   125     @Override

   126     public HttpClient.Version version() {

   127         return version;

   128     }

   129     // keepalive flag determines whether connection is closed or kept alive

   130     // by reading/skipping data

   131 

   132     /**

   133      * Returns a RawChannel that may be used for WebSocket protocol.

   134      * @implNote This implementation does not support RawChannel over

   135      *           HTTP/2 connections.

   136      * @return a RawChannel that may be used for WebSocket protocol.

   137      * @throws UnsupportedOperationException if getting a RawChannel over

   138      *         this connection is not supported.

   139      * @throws IOException if an I/O exception occurs while retrieving

   140      *         the channel.

   141      */

   142     @Override

   143     public synchronized RawChannel rawChannel() throws IOException {

   144         if (rawchan == null) {

   145             ExchangeImpl<?> exchImpl = exchangeImpl();

   146             if (!(exchImpl instanceof Http1Exchange)) {

   147                 // RawChannel is only used for WebSocket - and WebSocket

   148                 // is not supported over HTTP/2 yet, so we should not come

   149                 // here. Getting a RawChannel over HTTP/2 might be supported

   150                 // in the future, but it would entail retrieving any left over

   151                 // bytes that might have been read but not consumed by the

   152                 // HTTP/2 connection.

   153                 throw new UnsupportedOperationException("RawChannel is not supported over HTTP/2");

   154             }

   155             // Http1Exchange may have some remaining bytes in its

   156             // internal buffer.

   157             Supplier<ByteBuffer> initial = ((Http1Exchange<?>)exchImpl)::drainLeftOverBytes;

   158             rawchan = new RawChannelImpl(exchange.client(), connection, initial);

   159         }

   160         return rawchan;

   161     }

   162 

   163     @Override

   164     public String toString() {

   165         StringBuilder sb = new StringBuilder();

   166         String method = request().method();

   167         URI uri = request().uri();

   168         String uristring = uri == null ? "" : uri.toString();

   169         sb.append('(')

   170           .append(method)

   171           .append(" ")

   172           .append(uristring)

   173           .append(") ")

   174           .append(statusCode());

   175         return sb.toString();

   176     }

   177 }