1 /*

     2  * Copyright (c) 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 sun.net.util;

    27 

    28 import java.io.IOException;

    29 import java.lang.reflect.Constructor;

    30 import java.net.InetSocketAddress;

    31 import java.security.AccessController;

    32 import java.security.PrivilegedAction;

    33 import java.security.Security;

    34 

    35 public final class SocketExceptions {

    36     private SocketExceptions() {}

    37 

    38     /**

    39      * Security or system property which specifies categories of

    40      * (potentially sensitive) information that may be included

    41      * in exception text. This class only defines one category:

    42      * "hostInfo" which represents the hostname and port number

    43      * of the remote peer relating to a socket exception.

    44      * The property value is a comma separated list of

    45      * case insignificant category names.

    46      */

    47     private static final String enhancedTextPropname = "jdk.net.includeInExceptions";

    48 

    49     private static final boolean enhancedExceptionText = initTextProp();

    50 

    51     private static boolean initTextProp() {

    52         return AccessController.doPrivileged(new PrivilegedAction<Boolean>() {

    53             public Boolean run() {

    54                 String val = System.getProperty(enhancedTextPropname);

    55                 if (val == null) {

    56                     val = Security.getProperty(enhancedTextPropname);

    57                     if (val == null)

    58                         return false;

    59                 }

    60                 String[] tokens = val.split(",");

    61                 for (String token : tokens) {

    62                     if (token.equalsIgnoreCase("hostinfo"))

    63                         return true;

    64                 }

    65                 return false;

    66             }

    67         });

    68     }

    69 

    70 

    71     /**

    72      * Utility which takes an exception and returns either the same exception

    73      * or a new exception of the same type with the same stack trace

    74      * and detail message enhanced with addressing information from the

    75      * given InetSocketAddress.

    76      *

    77      * If the system/security property "jdk.net.enhanceExceptionText" is not

    78      * set or is false, then the original exception is returned.

    79      *

    80      * Only specific IOException subtypes are supported.

    81      */

    82     public static IOException of(IOException e, InetSocketAddress address) {

    83         if (!enhancedExceptionText || address == null)

    84             return e;

    85         int port = address.getPort();

    86         String host = address.getHostString();

    87         StringBuilder sb = new StringBuilder();

    88         sb.append(e.getMessage());

    89         sb.append(": ");

    90         sb.append(host);

    91         sb.append(':');

    92         sb.append(Integer.toString(port));

    93         String enhancedMsg = sb.toString();

    94         return create(e, enhancedMsg);

    95     }

    96 

    97     // return a new instance of the same type with the given detail

    98     // msg, or if the type doesn't support detail msgs, return given

    99     // instance.

   100 

   101     private static IOException create(IOException e, String msg) {

   102         return AccessController.doPrivileged(new PrivilegedAction<IOException>() {

   103             public IOException run() {

   104                 try {

   105                     Class<?> clazz = e.getClass();

   106                     Constructor<?> ctor = clazz.getConstructor(String.class);

   107                     IOException e1 = (IOException)(ctor.newInstance(msg));

   108                     e1.setStackTrace(e.getStackTrace());

   109                     return e1;

   110                 } catch (Exception e0) {

   111                     // Some eg AsynchronousCloseException have no detail msg

   112                     return e;

   113                 }

   114             }

   115         });

   116     }

   117 }