1 /*

     2  * Copyright (c) 1996, 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 /*

    27  * NOTE: This class lives in the package sun.net.www.protocol.https.

    28  * There is a copy in com.sun.net.ssl.internal.www.protocol.https for JSSE

    29  * 1.0.2 compatibility. It is 100% identical except the package and extends

    30  * lines. Any changes should be made to be class in sun.net.* and then copied

    31  * to com.sun.net.*.

    32  */

    33 

    34 // For both copies of the file, uncomment one line and comment the other

    35 // package sun.net.www.protocol.https;

    36 package com.sun.net.ssl.internal.www.protocol.https;

    37 

    38 import java.net.URL;

    39 import java.net.Proxy;

    40 import java.net.ProtocolException;

    41 import java.net.MalformedURLException;

    42 import java.io.*;

    43 import java.net.Authenticator;

    44 import javax.net.ssl.*;

    45 import java.security.Permission;

    46 import java.util.Map;

    47 import java.util.List;

    48 import sun.net.www.http.HttpClient;

    49 

    50 /**

    51  * A class to represent an HTTP connection to a remote object.

    52  *

    53  * Ideally, this class should subclass and inherit the http handler

    54  * implementation, but it can't do so because that class have the

    55  * wrong Java Type.  Thus it uses the delegate (aka, the

    56  * Adapter/Wrapper design pattern) to reuse code from the http

    57  * handler.

    58  *

    59  * Since it would use a delegate to access

    60  * sun.net.www.protocol.http.HttpURLConnection functionalities, it

    61  * needs to implement all public methods in it's super class and all

    62  * the way to Object.

    63  *

    64  */

    65 

    66 // For both copies of the file, uncomment one line and comment the other

    67 // public class HttpsURLConnectionImpl

    68 //      extends javax.net.ssl.HttpsURLConnection {

    69 @Deprecated(since="9")

    70 @SuppressWarnings("deprecation") // HttpsURLConnection is deprecated

    71 public class HttpsURLConnectionOldImpl

    72         extends com.sun.net.ssl.HttpsURLConnection {

    73 

    74     private DelegateHttpsURLConnection delegate;

    75 

    76 // For both copies of the file, uncomment one line and comment the other

    77 //    HttpsURLConnectionImpl(URL u, Handler handler) throws IOException {

    78     HttpsURLConnectionOldImpl(URL u, Handler handler) throws IOException {

    79         this(u, null, handler);

    80     }

    81 

    82     static URL checkURL(URL u) throws IOException {

    83         if (u != null) {

    84             if (u.toExternalForm().indexOf('\n') > -1) {

    85                 throw new MalformedURLException("Illegal character in URL");

    86             }

    87         }

    88         return u;

    89     }

    90 // For both copies of the file, uncomment one line and comment the other

    91 //    HttpsURLConnectionImpl(URL u, Handler handler) throws IOException {

    92     HttpsURLConnectionOldImpl(URL u, Proxy p, Handler handler) throws IOException {

    93         super(checkURL(u));

    94         delegate = new DelegateHttpsURLConnection(url, p, handler, this);

    95     }

    96 

    97     /**

    98      * Create a new HttpClient object, bypassing the cache of

    99      * HTTP client objects/connections.

   100      *

   101      * @param url       the URL being accessed

   102      */

   103     protected void setNewClient(URL url) throws IOException {

   104         delegate.setNewClient(url, false);

   105     }

   106 

   107     /**

   108      * Obtain a HttpClient object. Use the cached copy if specified.

   109      *

   110      * @param url       the URL being accessed

   111      * @param useCache  whether the cached connection should be used

   112      *                  if present

   113      */

   114     protected void setNewClient(URL url, boolean useCache)

   115             throws IOException {

   116         delegate.setNewClient(url, useCache);

   117     }

   118 

   119     /**

   120      * Create a new HttpClient object, set up so that it uses

   121      * per-instance proxying to the given HTTP proxy.  This

   122      * bypasses the cache of HTTP client objects/connections.

   123      *

   124      * @param url       the URL being accessed

   125      * @param proxyHost the proxy host to use

   126      * @param proxyPort the proxy port to use

   127      */

   128     protected void setProxiedClient(URL url, String proxyHost, int proxyPort)

   129             throws IOException {

   130         delegate.setProxiedClient(url, proxyHost, proxyPort);

   131     }

   132 

   133     /**

   134      * Obtain a HttpClient object, set up so that it uses per-instance

   135      * proxying to the given HTTP proxy. Use the cached copy of HTTP

   136      * client objects/connections if specified.

   137      *

   138      * @param url       the URL being accessed

   139      * @param proxyHost the proxy host to use

   140      * @param proxyPort the proxy port to use

   141      * @param useCache  whether the cached connection should be used

   142      *                  if present

   143      */

   144     protected void setProxiedClient(URL url, String proxyHost, int proxyPort,

   145             boolean useCache) throws IOException {

   146         delegate.setProxiedClient(url, proxyHost, proxyPort, useCache);

   147     }

   148 

   149     /**

   150      * Implements the HTTP protocol handler's "connect" method,

   151      * establishing an SSL connection to the server as necessary.

   152      */

   153     public void connect() throws IOException {

   154         delegate.connect();

   155     }

   156 

   157     /**

   158      * Used by subclass to access "connected" variable.  Since we are

   159      * delegating the actual implementation to "delegate", we need to

   160      * delegate the access of "connected" as well.

   161      */

   162     protected boolean isConnected() {

   163         return delegate.isConnected();

   164     }

   165 

   166     /**

   167      * Used by subclass to access "connected" variable.  Since we are

   168      * delegating the actual implementation to "delegate", we need to

   169      * delegate the access of "connected" as well.

   170      */

   171     protected void setConnected(boolean conn) {

   172         delegate.setConnected(conn);

   173     }

   174 

   175     /**

   176      * Returns the cipher suite in use on this connection.

   177      */

   178     public String getCipherSuite() {

   179         return delegate.getCipherSuite();

   180     }

   181 

   182     /**

   183      * Returns the certificate chain the client sent to the

   184      * server, or null if the client did not authenticate.

   185      */

   186     public java.security.cert.Certificate []

   187         getLocalCertificates() {

   188         return delegate.getLocalCertificates();

   189     }

   190 

   191     /**

   192      * Returns the server's certificate chain, or throws

   193      * SSLPeerUnverified Exception if

   194      * the server did not authenticate.

   195      */

   196     public java.security.cert.Certificate []

   197         getServerCertificates() throws SSLPeerUnverifiedException {

   198         return delegate.getServerCertificates();

   199     }

   200 

   201     /*

   202      * Allowable input/output sequences:

   203      * [interpreted as POST/PUT]

   204      * - get output, [write output,] get input, [read input]

   205      * - get output, [write output]

   206      * [interpreted as GET]

   207      * - get input, [read input]

   208      * Disallowed:

   209      * - get input, [read input,] get output, [write output]

   210      */

   211 

   212     public synchronized OutputStream getOutputStream() throws IOException {

   213         return delegate.getOutputStream();

   214     }

   215 

   216     public synchronized InputStream getInputStream() throws IOException {

   217         return delegate.getInputStream();

   218     }

   219 

   220     public InputStream getErrorStream() {

   221         return delegate.getErrorStream();

   222     }

   223 

   224     /**

   225      * Disconnect from the server.

   226      */

   227     public void disconnect() {

   228         delegate.disconnect();

   229     }

   230 

   231     public boolean usingProxy() {

   232         return delegate.usingProxy();

   233     }

   234 

   235     /**

   236      * Returns an unmodifiable Map of the header fields.

   237      * The Map keys are Strings that represent the

   238      * response-header field names. Each Map value is an

   239      * unmodifiable List of Strings that represents

   240      * the corresponding field values.

   241      *

   242      * @return a Map of header fields

   243      * @since 1.4

   244      */

   245     public Map<String,List<String>> getHeaderFields() {

   246         return delegate.getHeaderFields();

   247     }

   248 

   249     /**

   250      * Gets a header field by name. Returns null if not known.

   251      * @param name the name of the header field

   252      */

   253     public String getHeaderField(String name) {

   254         return delegate.getHeaderField(name);

   255     }

   256 

   257     /**

   258      * Gets a header field by index. Returns null if not known.

   259      * @param n the index of the header field

   260      */

   261     public String getHeaderField(int n) {

   262         return delegate.getHeaderField(n);

   263     }

   264 

   265     /**

   266      * Gets a header field by index. Returns null if not known.

   267      * @param n the index of the header field

   268      */

   269     public String getHeaderFieldKey(int n) {

   270         return delegate.getHeaderFieldKey(n);

   271     }

   272 

   273     /**

   274      * Sets request property. If a property with the key already

   275      * exists, overwrite its value with the new value.

   276      * @param value the value to be set

   277      */

   278     public void setRequestProperty(String key, String value) {

   279         delegate.setRequestProperty(key, value);

   280     }

   281 

   282     /**

   283      * Adds a general request property specified by a

   284      * key-value pair.  This method will not overwrite

   285      * existing values associated with the same key.

   286      *

   287      * @param   key     the keyword by which the request is known

   288      *                  (e.g., "<code>accept</code>").

   289      * @param   value  the value associated with it.

   290      * @see #getRequestProperties(java.lang.String)

   291      * @since 1.4

   292      */

   293     public void addRequestProperty(String key, String value) {

   294         delegate.addRequestProperty(key, value);

   295     }

   296 

   297     /**

   298      * Overwrite super class method

   299      */

   300     public int getResponseCode() throws IOException {

   301         return delegate.getResponseCode();

   302     }

   303 

   304     public String getRequestProperty(String key) {

   305         return delegate.getRequestProperty(key);

   306     }

   307 

   308     /**

   309      * Returns an unmodifiable Map of general request

   310      * properties for this connection. The Map keys

   311      * are Strings that represent the request-header

   312      * field names. Each Map value is a unmodifiable List

   313      * of Strings that represents the corresponding

   314      * field values.

   315      *

   316      * @return  a Map of the general request properties for this connection.

   317      * @throws IllegalStateException if already connected

   318      * @since 1.4

   319      */

   320     public Map<String,List<String>> getRequestProperties() {

   321         return delegate.getRequestProperties();

   322     }

   323 

   324     /*

   325      * We support JDK 1.2.x so we can't count on these from JDK 1.3.

   326      * We override and supply our own version.

   327      */

   328     public void setInstanceFollowRedirects(boolean shouldFollow) {

   329         delegate.setInstanceFollowRedirects(shouldFollow);

   330     }

   331 

   332     public boolean getInstanceFollowRedirects() {

   333         return delegate.getInstanceFollowRedirects();

   334     }

   335 

   336     public void setRequestMethod(String method) throws ProtocolException {

   337         delegate.setRequestMethod(method);

   338     }

   339 

   340     public String getRequestMethod() {

   341         return delegate.getRequestMethod();

   342     }

   343 

   344     public String getResponseMessage() throws IOException {

   345         return delegate.getResponseMessage();

   346     }

   347 

   348     public long getHeaderFieldDate(String name, long Default) {

   349         return delegate.getHeaderFieldDate(name, Default);

   350     }

   351 

   352     public Permission getPermission() throws IOException {

   353         return delegate.getPermission();

   354     }

   355 

   356     public URL getURL() {

   357         return delegate.getURL();

   358     }

   359 

   360     public int getContentLength() {

   361         return delegate.getContentLength();

   362     }

   363 

   364     public long getContentLengthLong() {

   365         return delegate.getContentLengthLong();

   366     }

   367 

   368     public String getContentType() {

   369         return delegate.getContentType();

   370     }

   371 

   372     public String getContentEncoding() {

   373         return delegate.getContentEncoding();

   374     }

   375 

   376     public long getExpiration() {

   377         return delegate.getExpiration();

   378     }

   379 

   380     public long getDate() {

   381         return delegate.getDate();

   382     }

   383 

   384     public long getLastModified() {

   385         return delegate.getLastModified();

   386     }

   387 

   388     public int getHeaderFieldInt(String name, int Default) {

   389         return delegate.getHeaderFieldInt(name, Default);

   390     }

   391 

   392     public long getHeaderFieldLong(String name, long Default) {

   393         return delegate.getHeaderFieldLong(name, Default);

   394     }

   395 

   396     public Object getContent() throws IOException {

   397         return delegate.getContent();

   398     }

   399 

   400     @SuppressWarnings("rawtypes")

   401     public Object getContent(Class[] classes) throws IOException {

   402         return delegate.getContent(classes);

   403     }

   404 

   405     public String toString() {

   406         return delegate.toString();

   407     }

   408 

   409     public void setDoInput(boolean doinput) {

   410         delegate.setDoInput(doinput);

   411     }

   412 

   413     public boolean getDoInput() {

   414         return delegate.getDoInput();

   415     }

   416 

   417     public void setDoOutput(boolean dooutput) {

   418         delegate.setDoOutput(dooutput);

   419     }

   420 

   421     public boolean getDoOutput() {

   422         return delegate.getDoOutput();

   423     }

   424 

   425     public void setAllowUserInteraction(boolean allowuserinteraction) {

   426         delegate.setAllowUserInteraction(allowuserinteraction);

   427     }

   428 

   429     public boolean getAllowUserInteraction() {

   430         return delegate.getAllowUserInteraction();

   431     }

   432 

   433     public void setUseCaches(boolean usecaches) {

   434         delegate.setUseCaches(usecaches);

   435     }

   436 

   437     public boolean getUseCaches() {

   438         return delegate.getUseCaches();

   439     }

   440 

   441     public void setIfModifiedSince(long ifmodifiedsince) {

   442         delegate.setIfModifiedSince(ifmodifiedsince);

   443     }

   444 

   445     public long getIfModifiedSince() {

   446         return delegate.getIfModifiedSince();

   447     }

   448 

   449     public boolean getDefaultUseCaches() {

   450         return delegate.getDefaultUseCaches();

   451     }

   452 

   453     public void setDefaultUseCaches(boolean defaultusecaches) {

   454         delegate.setDefaultUseCaches(defaultusecaches);

   455     }

   456 

   457     /*

   458      * finalize (dispose) the delegated object.  Otherwise

   459      * sun.net.www.protocol.http.HttpURLConnection's finalize()

   460      * would have to be made public.

   461      */

   462     protected void finalize() throws Throwable {

   463         delegate.dispose();

   464     }

   465 

   466     public boolean equals(Object obj) {

   467         return delegate.equals(obj);

   468     }

   469 

   470     public int hashCode() {

   471         return delegate.hashCode();

   472     }

   473 

   474     public void setConnectTimeout(int timeout) {

   475         delegate.setConnectTimeout(timeout);

   476     }

   477 

   478     public int getConnectTimeout() {

   479         return delegate.getConnectTimeout();

   480     }

   481 

   482     public void setReadTimeout(int timeout) {

   483         delegate.setReadTimeout(timeout);

   484     }

   485 

   486     public int getReadTimeout() {

   487         return delegate.getReadTimeout();

   488     }

   489 

   490     public void setFixedLengthStreamingMode (int contentLength) {

   491         delegate.setFixedLengthStreamingMode(contentLength);

   492     }

   493 

   494     public void setFixedLengthStreamingMode(long contentLength) {

   495         delegate.setFixedLengthStreamingMode(contentLength);

   496     }

   497 

   498     public void setChunkedStreamingMode (int chunklen) {

   499         delegate.setChunkedStreamingMode(chunklen);

   500     }

   501 

   502     @Override

   503     public void setAuthenticator(Authenticator auth) {

   504         delegate.setAuthenticator(auth);

   505     }

   506 }