1 /*

     2  * Copyright (c) 1996, 2012, 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 package sun.rmi.transport.proxy;

    26 

    27 import java.io.*;

    28 import java.net.*;

    29 import java.security.PrivilegedAction;

    30 

    31 import sun.rmi.runtime.Log;

    32 

    33 /**

    34  * The HttpSendSocket class extends the java.net.Socket class

    35  * by enclosing the data output stream in, then extracting the input

    36  * stream from, an HTTP protocol transmission.

    37  *

    38  * NOTES:

    39  *

    40  * Since the length of the output request must be known before the

    41  * HTTP header can be completed, all of the output is buffered by

    42  * an HttpOutputStream object until either an attempt is made to

    43  * read from this socket, or the socket is explicitly closed.

    44  *

    45  * On the first read attempt to read from this socket, the buffered

    46  * output is sent to the destination as the body of an HTTP POST

    47  * request.  All reads will then acquire data from the body of

    48  * the response.  A subsequent attempt to write to this socket will

    49  * throw an IOException.

    50  */

    51 class HttpSendSocket extends Socket implements RMISocketInfo {

    52 

    53     /** the host to connect to */

    54     protected String host;

    55 

    56     /** the port to connect to */

    57     protected int port;

    58 

    59     /** the URL to forward through */

    60     protected URL url;

    61 

    62     /** the object managing this connection through the URL */

    63     protected URLConnection conn = null;

    64 

    65     /** internal input stream for this socket */

    66     protected InputStream in = null;

    67 

    68     /** internal output stream for this socket */

    69     protected OutputStream out = null;

    70 

    71     /** the notifying input stream returned to users */

    72     protected HttpSendInputStream inNotifier;

    73 

    74     /** the notifying output stream returned to users */

    75     protected HttpSendOutputStream outNotifier;

    76 

    77     /**

    78      * Line separator string.  This is the value of the line.separator

    79      * property at the moment that the socket was created.

    80      */

    81     private String lineSeparator =

    82         java.security.AccessController.doPrivileged(

    83             (PrivilegedAction<String>) () -> System.getProperty("line.separator"));

    84 

    85     /**

    86      * Create a stream socket and connect it to the specified port on

    87      * the specified host.

    88      * @param host the host

    89      * @param port the port

    90      */

    91     public HttpSendSocket(String host, int port, URL url) throws IOException

    92     {

    93         super((SocketImpl)null);        // no underlying SocketImpl for this object

    94 

    95         if (RMIMasterSocketFactory.proxyLog.isLoggable(Log.VERBOSE)) {

    96             RMIMasterSocketFactory.proxyLog.log(Log.VERBOSE,

    97                 "host = " + host + ", port = " + port + ", url = " + url);

    98         }

    99 

   100         this.host = host;

   101         this.port = port;

   102         this.url = url;

   103 

   104         inNotifier = new HttpSendInputStream(null, this);

   105         outNotifier = new HttpSendOutputStream(writeNotify(), this);

   106     }

   107 

   108     /**

   109      * Create a stream socket and connect it to the specified port on

   110      * the specified host.

   111      * @param host the host

   112      * @param port the port

   113      */

   114     public HttpSendSocket(String host, int port) throws IOException

   115     {

   116         this(host, port, new URL("http", host, port, "/"));

   117     }

   118 

   119     /**

   120      * Create a stream socket and connect it to the specified address on

   121      * the specified port.

   122      * @param address the address

   123      * @param port the port

   124      */

   125     public HttpSendSocket(InetAddress address, int port) throws IOException

   126     {

   127         this(address.getHostName(), port);

   128     }

   129 

   130     /**

   131      * Indicate that this socket is not reusable.

   132      */

   133     public boolean isReusable()

   134     {

   135         return false;

   136     }

   137 

   138     /**

   139      * Create a new socket connection to host (or proxy), and prepare to

   140      * send HTTP transmission.

   141      */

   142     public synchronized OutputStream writeNotify() throws IOException

   143     {

   144         if (conn != null) {

   145             throw new IOException("attempt to write on HttpSendSocket after " +

   146                                   "request has been sent");

   147         }

   148 

   149         conn = url.openConnection();

   150         conn.setDoOutput(true);

   151         conn.setUseCaches(false);

   152         conn.setRequestProperty("Content-type", "application/octet-stream");

   153 

   154         inNotifier.deactivate();

   155         in = null;

   156 

   157         return out = conn.getOutputStream();

   158     }

   159 

   160     /**

   161      * Send HTTP output transmission and prepare to receive response.

   162      */

   163     public synchronized InputStream readNotify() throws IOException

   164     {

   165         RMIMasterSocketFactory.proxyLog.log(Log.VERBOSE,

   166             "sending request and activating input stream");

   167 

   168         outNotifier.deactivate();

   169         out.close();

   170         out = null;

   171 

   172         try {

   173             in = conn.getInputStream();

   174         } catch (IOException e) {

   175             RMIMasterSocketFactory.proxyLog.log(Log.BRIEF,

   176                 "failed to get input stream, exception: ", e);

   177 

   178             throw new IOException("HTTP request failed");

   179         }

   180 

   181         /*

   182          * If an HTTP error response is returned, sometimes an IOException

   183          * is thrown, which is handled above, and other times it isn't, and

   184          * the error response body will be available for reading.

   185          * As a safety net to catch any such unexpected HTTP behavior, we

   186          * verify that the content type of the response is what the

   187          * HttpOutputStream generates: "application/octet-stream".

   188          * (Servers' error responses will generally be "text/html".)

   189          * Any error response body is printed to the log.

   190          */

   191         String contentType = conn.getContentType();

   192         if (contentType == null ||

   193             !conn.getContentType().equals("application/octet-stream"))

   194         {

   195             if (RMIMasterSocketFactory.proxyLog.isLoggable(Log.BRIEF)) {

   196                 String message;

   197                 if (contentType == null) {

   198                     message = "missing content type in response" +

   199                         lineSeparator;

   200                 } else {

   201                     message = "invalid content type in response: " +

   202                         contentType + lineSeparator;

   203                 }

   204 

   205                 message += "HttpSendSocket.readNotify: response body: ";

   206                 try {

   207                     BufferedReader din = new BufferedReader(new InputStreamReader(in));

   208                     String line;

   209                     while ((line = din.readLine()) != null)

   210                         message += line + lineSeparator;

   211                 } catch (IOException e) {

   212                 }

   213                 RMIMasterSocketFactory.proxyLog.log(Log.BRIEF, message);

   214             }

   215 

   216             throw new IOException("HTTP request failed");

   217         }

   218 

   219         return in;

   220     }

   221 

   222     /**

   223      * Get the address to which the socket is connected.

   224      */

   225     public InetAddress getInetAddress()

   226     {

   227         try {

   228             return InetAddress.getByName(host);

   229         } catch (UnknownHostException e) {

   230             return null;        // null if couldn't resolve destination host

   231         }

   232     }

   233 

   234     /**

   235      * Get the local address to which the socket is bound.

   236      */

   237     public InetAddress getLocalAddress()

   238     {

   239         try {

   240             return InetAddress.getLocalHost();

   241         } catch (UnknownHostException e) {

   242             return null;        // null if couldn't determine local host

   243         }

   244     }

   245 

   246     /**

   247      * Get the remote port to which the socket is connected.

   248      */

   249     public int getPort()

   250     {

   251         return port;

   252     }

   253 

   254     /**

   255      * Get the local port to which the socket is connected.

   256      */

   257     public int getLocalPort()

   258     {

   259         return -1;      // request not applicable to this socket type

   260     }

   261 

   262     /**

   263      * Get an InputStream for this socket.

   264      */

   265     public InputStream getInputStream() throws IOException

   266     {

   267         return inNotifier;

   268     }

   269 

   270     /**

   271      * Get an OutputStream for this socket.

   272      */

   273     public OutputStream getOutputStream() throws IOException

   274     {

   275         return outNotifier;

   276     }

   277 

   278     /**

   279      * Enable/disable TCP_NODELAY.

   280      * This operation has no effect for an HttpSendSocket.

   281      */

   282     public void setTcpNoDelay(boolean on) throws SocketException

   283     {

   284     }

   285 

   286     /**

   287      * Retrieve whether TCP_NODELAY is enabled.

   288      */

   289     public boolean getTcpNoDelay() throws SocketException

   290     {

   291         return false;   // imply option is disabled

   292     }

   293 

   294     /**

   295      * Enable/disable SO_LINGER with the specified linger time.

   296      * This operation has no effect for an HttpSendSocket.

   297      */

   298     public void setSoLinger(boolean on, int val) throws SocketException

   299     {

   300     }

   301 

   302     /**

   303      * Retrive setting for SO_LINGER.

   304      */

   305     public int getSoLinger() throws SocketException

   306     {

   307         return -1;      // imply option is disabled

   308     }

   309 

   310     /**

   311      * Enable/disable SO_TIMEOUT with the specified timeout

   312      * This operation has no effect for an HttpSendSocket.

   313      */

   314     public synchronized void setSoTimeout(int timeout) throws SocketException

   315     {

   316     }

   317 

   318     /**

   319      * Retrive setting for SO_TIMEOUT.

   320      */

   321     public synchronized int getSoTimeout() throws SocketException

   322     {

   323         return 0;       // imply option is disabled

   324     }

   325 

   326     /**

   327      * Close the socket.

   328      */

   329     public synchronized void close() throws IOException

   330     {

   331         if (out != null) // push out transmission if not done

   332             out.close();

   333     }

   334 

   335     /**

   336      * Return string representation of this pseudo-socket.

   337      */

   338     public String toString()

   339     {

   340         return "HttpSendSocket[host=" + host +

   341                ",port=" + port +

   342                ",url=" + url + "]";

   343     }

   344 }