--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.httpclient/share/classes/java/net/http/HttpRequestImpl.java Thu Feb 25 23:14:22 2016 +0000
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ */
+package java.net.http;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.ProxySelector;
+import java.net.URI;
+import java.net.http.HttpClient.Version;
+import java.net.http.HttpResponse.MultiProcessor;
+import java.util.concurrent.CompletableFuture;
+import java.net.SocketPermission;
+import java.security.AccessControlContext;
+import java.security.AccessController;
+import java.util.Set;
+import static java.net.http.HttpRedirectImpl.getRedirects;
+import java.util.Locale;
+
+class HttpRequestImpl extends HttpRequest {
+
+ private final HttpHeadersImpl userHeaders;
+ private final HttpHeadersImpl systemHeaders;
+ private final URI uri;
+ private InetSocketAddress authority; // only used when URI not specified
+ private final String method;
+ private final HttpClientImpl client;
+ private final HttpRedirectImpl followRedirects;
+ private final ProxySelector proxy;
+ final BodyProcessor requestProcessor;
+ final boolean secure;
+ final boolean expectContinue;
+ private final java.net.http.HttpClient.Version version;
+ private boolean isWebSocket;
+ final MultiExchange exchange;
+ private boolean receiving;
+ private AccessControlContext acc;
+ private final long timeval;
+
+ public HttpRequestImpl(HttpClientImpl client,
+ String method,
+ HttpRequestBuilderImpl builder) {
+ this.client = client;
+ this.method = method == null? "GET" : method;
+ this.userHeaders = builder.headers() == null ?
+ new HttpHeadersImpl() : builder.headers();
+ dropDisallowedHeaders();
+ this.followRedirects = getRedirects(builder.followRedirects() == null ?
+ client.followRedirects() : builder.followRedirects());
+ this.systemHeaders = new HttpHeadersImpl();
+ this.uri = builder.uri();
+ this.proxy = builder.proxy();
+ this.expectContinue = builder.expectContinue();
+ this.secure = uri.getScheme().toLowerCase(Locale.US).equals("https");
+ this.version = builder.version();
+ if (builder.body() == null) {
+ this.requestProcessor = HttpRequest.noBody();
+ } else {
+ this.requestProcessor = builder.body();
+ }
+ this.exchange = new MultiExchange(this);
+ this.timeval = builder.timeval();
+ }
+
+ /** Creates a HttpRequestImpl using fields of an existing request impl. */
+ public HttpRequestImpl(URI uri,
+ HttpRequest request,
+ HttpClientImpl client,
+ String method,
+ HttpRequestImpl other) {
+ this.client = client;
+ this.method = method == null? "GET" : method;
+ this.userHeaders = other.userHeaders == null ?
+ new HttpHeadersImpl() : other.userHeaders;
+ dropDisallowedHeaders();
+ this.followRedirects = getRedirects(other.followRedirects() == null ?
+ client.followRedirects() : other.followRedirects());
+ this.systemHeaders = other.systemHeaders;
+ this.uri = uri;
+ this.expectContinue = other.expectContinue;
+ this.secure = other.secure;
+ this.requestProcessor = other.requestProcessor;
+ this.proxy = other.proxy;
+ this.version = other.version;
+ this.acc = other.acc;
+ this.exchange = new MultiExchange(this);
+ this.timeval = other.timeval;
+ }
+
+ /* used for creating CONNECT requests */
+ HttpRequestImpl(HttpClientImpl client,
+ String method,
+ InetSocketAddress authority) {
+ this.client = client;
+ this.method = method;
+ this.followRedirects = getRedirects(client.followRedirects());
+ this.systemHeaders = new HttpHeadersImpl();
+ this.userHeaders = new HttpHeadersImpl();
+ this.uri = null;
+ this.proxy = null;
+ this.requestProcessor = HttpRequest.noBody();
+ this.version = java.net.http.HttpClient.Version.HTTP_1_1;
+ this.authority = authority;
+ this.secure = false;
+ this.expectContinue = false;
+ this.exchange = new MultiExchange(this);
+ this.timeval = 0; // block TODO: fix
+ }
+
+ @Override
+ public HttpClientImpl client() {
+ return client;
+ }
+
+
+ @Override
+ public String toString() {
+ return (uri == null ? "" : uri.toString()) + "/" + method + "("
+ + hashCode() + ")";
+ }
+
+ @Override
+ public HttpHeaders headers() {
+ userHeaders.makeUnmodifiable();
+ return userHeaders;
+ }
+
+ InetSocketAddress authority() { return authority; }
+
+ void setH2Upgrade() {
+ Http2ClientImpl h2client = client.client2();
+ systemHeaders.setHeader("Connection", "Upgrade, HTTP2-Settings");
+ systemHeaders.setHeader("Upgrade", "h2c");
+ systemHeaders.setHeader("HTTP2-Settings", h2client.getSettingsString());
+ }
+
+ private static final Set<String> DISALLOWED_HEADERS_SET = Set.of(
+ "authorization", "connection", "cookie", "content-length",
+ "date", "expect", "from", "host", "origin", "proxy-authorization",
+ "referer", "user-agent", "upgrade", "via", "warning");
+
+
+ // we silently drop headers that are disallowed
+ private void dropDisallowedHeaders() {
+ Set<String> hdrnames = userHeaders.directMap().keySet();
+
+ hdrnames.removeIf((s) ->
+ DISALLOWED_HEADERS_SET.contains(s.toLowerCase())
+ );
+ }
+
+ private synchronized void receiving() {
+ if (receiving) {
+ throw new IllegalStateException("already receiving response");
+ }
+ receiving = true;
+ }
+
+ /*
+ * Response filters may result in a new HttpRequestImpl being created
+ * (but still associated with the same API HttpRequest) and the process
+ * is repeated.
+ */
+ @Override
+ public HttpResponse response() throws IOException, InterruptedException {
+ receiving(); // TODO: update docs
+ if (System.getSecurityManager() != null) {
+ acc = AccessController.getContext();
+ }
+ return exchange.response();
+ }
+
+ @Override
+ public synchronized CompletableFuture<HttpResponse> responseAsync() {
+ receiving(); // TODO: update docs
+ if (System.getSecurityManager() != null) {
+ acc = AccessController.getContext();
+ }
+ return exchange.responseAsync(null)
+ .thenApply((r) -> (HttpResponse)r);
+ }
+
+ public <U> CompletableFuture<U>
+ sendAsyncMulti(HttpResponse.MultiProcessor<U> rspproc) {
+ // To change body of generated methods, choose Tools | Templates.
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean expectContinue() { return expectContinue; }
+
+ public boolean requestHttp2() {
+ return version.equals(HttpClient.Version.HTTP_2);
+ //return client.getHttp2Allowed();
+ }
+
+ AccessControlContext getAccessControlContext() { return acc; }
+
+ InetSocketAddress proxy() {
+ ProxySelector ps = this.proxy;
+ if (ps == null) {
+ ps = client.proxy().orElse(null);
+ }
+ if (ps == null || method.equalsIgnoreCase("CONNECT")) {
+ return null;
+ }
+ return (InetSocketAddress)ps.select(uri).get(0).address();
+ }
+
+ boolean secure() { return secure; }
+
+ void isWebSocket(boolean is) {
+ isWebSocket = is;
+ }
+
+ boolean isWebSocket() {
+ return isWebSocket;
+ }
+
+ /** Returns the follow-redirects setting for this request. */
+ @Override
+ public java.net.http.HttpClient.Redirect followRedirects() {
+ return getRedirects(followRedirects);
+ }
+
+ HttpRedirectImpl followRedirectsImpl() { return followRedirects; }
+
+ /**
+ * Returns the request method for this request. If not set explicitly,
+ * the default method for any request is "GET".
+ */
+ @Override
+ public String method() { return method; }
+
+ @Override
+ public URI uri() { return uri; }
+
+ HttpHeadersImpl getUserHeaders() { return userHeaders; }
+
+ HttpHeadersImpl getSystemHeaders() { return systemHeaders; }
+
+ HttpClientImpl getClient() { return client; }
+
+ BodyProcessor requestProcessor() { return requestProcessor; }
+
+ @Override
+ public Version version() { return version; }
+
+ void addSystemHeader(String name, String value) {
+ systemHeaders.addHeader(name, value);
+ }
+
+ void setSystemHeader(String name, String value) {
+ systemHeaders.setHeader(name, value);
+ }
+
+ long timeval() { return timeval; }
+
+ @Override
+ public <U> CompletableFuture<U>
+ multiResponseAsync(MultiProcessor<U> rspproc) {
+ //To change body of generated methods, choose Tools | Templates.
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+}