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.net.URI;

    29 import java.time.Duration;

    30 import java.util.Optional;

    31 import java.net.http.HttpClient;

    32 import java.net.http.HttpRequest;

    33 import java.net.http.HttpRequest.BodyPublisher;

    34 import java.net.http.internal.common.HttpHeadersImpl;

    35 import java.net.http.internal.common.Utils;

    36 import static java.lang.String.format;

    37 import static java.util.Objects.requireNonNull;

    38 import static java.net.http.internal.common.Utils.isValidName;

    39 import static java.net.http.internal.common.Utils.isValidValue;

    40 

    41 public class HttpRequestBuilderImpl extends HttpRequest.Builder {

    42 

    43     private HttpHeadersImpl userHeaders;

    44     private URI uri;

    45     private String method;

    46     private boolean expectContinue;

    47     private BodyPublisher bodyPublisher;

    48     private volatile Optional<HttpClient.Version> version;

    49     private Duration duration;

    50 

    51     public HttpRequestBuilderImpl(URI uri) {

    52         requireNonNull(uri, "uri must be non-null");

    53         checkURI(uri);

    54         this.uri = uri;

    55         this.userHeaders = new HttpHeadersImpl();

    56         this.method = "GET"; // default, as per spec

    57         this.version = Optional.empty();

    58     }

    59 

    60     public HttpRequestBuilderImpl() {

    61         this.userHeaders = new HttpHeadersImpl();

    62         this.method = "GET"; // default, as per spec

    63         this.version = Optional.empty();

    64     }

    65 

    66     @Override

    67     public HttpRequestBuilderImpl uri(URI uri) {

    68         requireNonNull(uri, "uri must be non-null");

    69         checkURI(uri);

    70         this.uri = uri;

    71         return this;

    72     }

    73 

    74     private static IllegalArgumentException newIAE(String message, Object... args) {

    75         return new IllegalArgumentException(format(message, args));

    76     }

    77 

    78     private static void checkURI(URI uri) {

    79         String scheme = uri.getScheme();

    80         if (scheme == null)

    81             throw newIAE("URI with undefined scheme");

    82         scheme = scheme.toLowerCase();

    83         if (!(scheme.equals("https") || scheme.equals("http"))) {

    84             throw newIAE("invalid URI scheme %s", scheme);

    85         }

    86         if (uri.getHost() == null) {

    87             throw newIAE("unsupported URI %s", uri);

    88         }

    89     }

    90 

    91     @Override

    92     public HttpRequestBuilderImpl copy() {

    93         HttpRequestBuilderImpl b = new HttpRequestBuilderImpl(this.uri);

    94         b.userHeaders = this.userHeaders.deepCopy();

    95         b.method = this.method;

    96         b.expectContinue = this.expectContinue;

    97         b.bodyPublisher = bodyPublisher;

    98         b.uri = uri;

    99         b.duration = duration;

   100         b.version = version;

   101         return b;

   102     }

   103 

   104     private void checkNameAndValue(String name, String value) {

   105         requireNonNull(name, "name");

   106         requireNonNull(value, "value");

   107         if (!isValidName(name)) {

   108             throw newIAE("invalid header name: \"%s\"", name);

   109         }

   110         if (!Utils.ALLOWED_HEADERS.test(name)) {

   111             throw newIAE("restricted header name: \"%s\"", name);

   112         }

   113         if (!isValidValue(value)) {

   114             throw newIAE("invalid header value: \"%s\"", value);

   115         }

   116     }

   117 

   118     @Override

   119     public HttpRequestBuilderImpl setHeader(String name, String value) {

   120         checkNameAndValue(name, value);

   121         userHeaders.setHeader(name, value);

   122         return this;

   123     }

   124 

   125     @Override

   126     public HttpRequestBuilderImpl header(String name, String value) {

   127         checkNameAndValue(name, value);

   128         userHeaders.addHeader(name, value);

   129         return this;

   130     }

   131 

   132     @Override

   133     public HttpRequestBuilderImpl headers(String... params) {

   134         requireNonNull(params);

   135         if (params.length == 0 || params.length % 2 != 0) {

   136             throw newIAE("wrong number, %d, of parameters", params.length);

   137         }

   138         for (int i = 0; i < params.length; i += 2) {

   139             String name  = params[i];

   140             String value = params[i + 1];

   141             header(name, value);

   142         }

   143         return this;

   144     }

   145 

   146     @Override

   147     public HttpRequestBuilderImpl expectContinue(boolean enable) {

   148         expectContinue = enable;

   149         return this;

   150     }

   151 

   152     @Override

   153     public HttpRequestBuilderImpl version(HttpClient.Version version) {

   154         requireNonNull(version);

   155         this.version = Optional.of(version);

   156         return this;

   157     }

   158 

   159     HttpHeadersImpl headers() {  return userHeaders; }

   160 

   161     URI uri() { return uri; }

   162 

   163     String method() { return method; }

   164 

   165     boolean expectContinue() { return expectContinue; }

   166 

   167     BodyPublisher bodyPublisher() { return bodyPublisher; }

   168 

   169     Optional<HttpClient.Version> version() { return version; }

   170 

   171     @Override

   172     public HttpRequest.Builder GET() {

   173         return method0("GET", null);

   174     }

   175 

   176     @Override

   177     public HttpRequest.Builder POST(BodyPublisher body) {

   178         return method0("POST", requireNonNull(body));

   179     }

   180 

   181     @Override

   182     public HttpRequest.Builder DELETE(BodyPublisher body) {

   183         return method0("DELETE", requireNonNull(body));

   184     }

   185 

   186     @Override

   187     public HttpRequest.Builder PUT(BodyPublisher body) {

   188         return method0("PUT", requireNonNull(body));

   189     }

   190 

   191     @Override

   192     public HttpRequest.Builder method(String method, BodyPublisher body) {

   193         requireNonNull(method);

   194         if (method.equals(""))

   195             throw newIAE("illegal method <empty string>");

   196         if (method.equals("CONNECT"))

   197             throw newIAE("method CONNECT is not supported");

   198         return method0(method, requireNonNull(body));

   199     }

   200 

   201     private HttpRequest.Builder method0(String method, BodyPublisher body) {

   202         assert method != null;

   203         assert !method.equals("GET") ? body != null : true;

   204         assert !method.equals("");

   205         this.method = method;

   206         this.bodyPublisher = body;

   207         return this;

   208     }

   209 

   210     @Override

   211     public HttpRequest build() {

   212         if (uri == null)

   213             throw new IllegalStateException("uri is null");

   214         assert method != null;

   215         return new HttpRequestImpl(this);

   216     }

   217 

   218     @Override

   219     public HttpRequest.Builder timeout(Duration duration) {

   220         requireNonNull(duration);

   221         if (duration.isNegative() || Duration.ZERO.equals(duration))

   222             throw new IllegalArgumentException("Invalid duration: " + duration);

   223         this.duration = duration;

   224         return this;

   225     }

   226 

   227     Duration timeout() { return duration; }

   228 

   229 }