jdk-sandbox: comparison src/java.base/share/classes/java/net/URL.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import jdk.internal.access.JavaNetURLAccess;
 import jdk.internal.access.SharedSecrets;
+import sun.net.util.IPAddressUtil;
 import sun.security.util.SecurityConstants;
 import sun.security.action.GetPropertyAction;
 /**
 * Class {@code URL} represents a Uniform Resource
 * @since 1.0
 */
 public final class URL implements java.io.Serializable {
 static final String BUILTIN_HANDLERS_PREFIX = "sun.net.www.protocol";
+@java.io.Serial
 static final long serialVersionUID = -7627629688361524110L;
 /**
 * The property which specifies the package prefix list to be scanned
 * for protocol handlers.  The value of this property (if any) should
 *     subclass of {@code URLStreamHandler}, then a
 *     {@code MalformedURLException} is thrown.
 * </ol>
 *
 * <p>Protocol handlers for the following protocols are guaranteed
-* to exist on the search path :-
+* to exist on the search path:
-* <blockquote><pre>
+* <ul>
-*     http, https, file, and jar
+* <li>{@code http}</li>
-* </pre></blockquote>
+* <li>{@code https}</li>
+* <li>{@code file}</li>
+* <li>{@code jar}</li>
+* </ul>
 * Protocol handlers for additional protocols may also be  available.
 * Some protocol handlers, for example those used for loading platform
 * classes or classes on the class path, may not be overridden. The details
 * of such restrictions, and when those restrictions apply (during
 * initialization of the runtime for example), are implementation specific
 *
 * @param      protocol   the name of the protocol to use.
 * @param      host       the name of the host.
 * @param      port       the port number on the host.
 * @param      file       the file on the host
-* @exception  MalformedURLException  if an unknown protocol or the port
+* @throws     MalformedURLException  if an unknown protocol or the port
 *                  is a negative number other than -1
 * @see        java.lang.System#getProperty(java.lang.String)
 * @see        java.net.URL#setURLStreamHandlerFactory(
 *                  java.net.URLStreamHandlerFactory)
 * @see        java.net.URLStreamHandler
 * No validation of the inputs is performed by this constructor.
 *
 * @param      protocol   the name of the protocol to use.
 * @param      host       the name of the host.
 * @param      file       the file on the host.
-* @exception  MalformedURLException  if an unknown protocol is specified.
+* @throws     MalformedURLException  if an unknown protocol is specified.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *                  int, java.lang.String)
 */
 public URL(String protocol, String host, String file)
 throws MalformedURLException {
 * @param      protocol   the name of the protocol to use.
 * @param      host       the name of the host.
 * @param      port       the port number on the host.
 * @param      file       the file on the host
 * @param      handler    the stream handler for the URL.
-* @exception  MalformedURLException  if an unknown protocol or the port
+* @throws     MalformedURLException  if an unknown protocol or the port
 is a negative number other than -1
-* @exception  SecurityException
+* @throws     SecurityException
 *        if a security manager exists and its
 *        {@code checkPermission} method doesn't allow
 *        specifying a stream handler explicitly.
 * @see        java.lang.System#getProperty(java.lang.String)
 * @see        java.net.URL#setURLStreamHandlerFactory(
 } else {
 this.path = file;
 this.file = path;
 }
-// Note: we don't do validation of the URL here. Too risky to change
+// Note: we don't do full validation of the URL here. Too risky to change
 // right now, but worth considering for future reference. -br
 if (handler == null &&
 (handler = getURLStreamHandler(protocol)) == null) {
 throw new MalformedURLException("unknown protocol: " + protocol);
 }
 this.handler = handler;
+if (host != null && isBuiltinStreamHandler(handler)) {
+String s = IPAddressUtil.checkExternalForm(this);
+if (s != null) {
+throw new MalformedURLException(s);
+}
+}
+if ("jar".equalsIgnoreCase(protocol)) {
+if (handler instanceof sun.net.www.protocol.jar.Handler) {
+// URL.openConnection() would throw a confusing exception
+// so generate a better exception here instead.
+String s = ((sun.net.www.protocol.jar.Handler) handler).checkNestedProtocol(file);
+if (s != null) {
+throw new MalformedURLException(s);
+}
+}
+}
 }
 /**
 * Creates a {@code URL} object from the {@code String}
 * representation.
 * <p>
 * This constructor is equivalent to a call to the two-argument
 * constructor with a {@code null} first argument.
 *
 * @param      spec   the {@code String} to parse as a URL.
-* @exception  MalformedURLException  if no protocol is specified, or an
+* @throws     MalformedURLException  if no protocol is specified, or an
 *               unknown protocol is found, or {@code spec} is {@code null},
 *               or the parsed URL fails to comply with the specific syntax
 *               of the associated protocol.
 * @see        java.net.URL#URL(java.net.URL, java.lang.String)
 */
 * <p>
 * For a more detailed description of URL parsing, refer to RFC2396.
 *
 * @param      context   the context in which to parse the specification.
 * @param      spec      the {@code String} to parse as a URL.
-* @exception  MalformedURLException  if no protocol is specified, or an
+* @throws     MalformedURLException  if no protocol is specified, or an
 *               unknown protocol is found, or {@code spec} is {@code null},
 *               or the parsed URL fails to comply with the specific syntax
 *               of the associated protocol.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *                  int, java.lang.String)
 * occurs as with the two argument constructor.
 *
 * @param      context   the context in which to parse the specification.
 * @param      spec      the {@code String} to parse as a URL.
 * @param      handler   the stream handler for the URL.
-* @exception  MalformedURLException  if no protocol is specified, or an
+* @throws     MalformedURLException  if no protocol is specified, or an
 *               unknown protocol is found, or {@code spec} is {@code null},
 *               or the parsed URL fails to comply with the specific syntax
 *               of the associated protocol.
-* @exception  SecurityException
+* @throws     SecurityException
 *        if a security manager exists and its
 *        {@code checkPermission} method doesn't allow
 *        specifying a stream handler.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *                  int, java.lang.String)
 * This method functions in the same way as {@code new URI (this.toString())}.
 * <p>Note, any URL instance that complies with RFC 2396 can be converted
 * to a URI. However, some URLs that are not strictly in compliance
 * can not be converted to a URI.
 *
-* @exception URISyntaxException if this URL is not formatted strictly according to
+* @throws    URISyntaxException if this URL is not formatted strictly according to
 *            RFC2396 and cannot be converted to a URI.
 *
 * @return    a URI instance equivalent to this URL.
 * @since 1.5
 */
 public URI toURI() throws URISyntaxException {
-return new URI (toString());
+URI uri = new URI(toString());
+if (authority != null && isBuiltinStreamHandler(handler)) {
+String s = IPAddressUtil.checkAuthority(this);
+if (s != null) throw new URISyntaxException(authority, s);
+}
+return uri;
 }
 /**
 * Returns a {@link java.net.URLConnection URLConnection} instance that
 * represents a connection to the remote object referred to by the
 * HttpURLConnection will be returned, and for JAR a
 * JarURLConnection will be returned.</P>
 *
 * @return     a {@link java.net.URLConnection URLConnection} linking
 *             to the URL.
-* @exception  IOException  if an I/O exception occurs.
+* @throws     IOException  if an I/O exception occurs.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *             int, java.lang.String)
 */
 public URLConnection openConnection() throws java.io.IOException {
 return handler.openConnection(this);
 *
 * @param      proxy the Proxy through which this connection
 *             will be made. If direct connection is desired,
 *             Proxy.NO_PROXY should be specified.
 * @return     a {@code URLConnection} to the URL.
-* @exception  IOException  if an I/O exception occurs.
+* @throws     IOException  if an I/O exception occurs.
-* @exception  SecurityException if a security manager is present
+* @throws     SecurityException if a security manager is present
 *             and the caller doesn't have permission to connect
 *             to the proxy.
-* @exception  IllegalArgumentException will be thrown if proxy is null,
+* @throws     IllegalArgumentException will be thrown if proxy is null,
 *             or proxy has the wrong type
-* @exception  UnsupportedOperationException if the subclass that
+* @throws     UnsupportedOperationException if the subclass that
 *             implements the protocol handler doesn't support
 *             this method.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *             int, java.lang.String)
 * @see        java.net.URLConnection
 * <blockquote><pre>
 *     openConnection().getInputStream()
 * </pre></blockquote>
 *
 * @return     an input stream for reading from the URL connection.
-* @exception  IOException  if an I/O exception occurs.
+* @throws     IOException  if an I/O exception occurs.
 * @see        java.net.URL#openConnection()
 * @see        java.net.URLConnection#getInputStream()
 */
 public final InputStream openStream() throws java.io.IOException {
 return openConnection().getInputStream();
 * <blockquote><pre>
 *     openConnection().getContent()
 * </pre></blockquote>
 *
 * @return     the contents of this URL.
-* @exception  IOException  if an I/O exception occurs.
+* @throws     IOException  if an I/O exception occurs.
 * @see        java.net.URLConnection#getContent()
 */
 public final Object getContent() throws java.io.IOException {
 return openConnection().getContent();
 }
 *
 * @param classes an array of Java types
 * @return     the content object of this URL that is the first match of
 *               the types specified in the classes array.
 *               null if none of the requested types are supported.
-* @exception  IOException  if an I/O exception occurs.
+* @throws     IOException  if an I/O exception occurs.
 * @see        java.net.URLConnection#getContent(Class[])
 * @since 1.3
 */
 public final Object getContent(Class<?>[] classes)
 throws java.io.IOException {
 * the security manager's {@code checkSetFactory} method
 * to ensure the operation is allowed.
 * This could result in a SecurityException.
 *
 * @param      fac   the desired factory.
-* @exception  Error  if the application has already set a factory.
+* @throws     Error  if the application has already set a factory.
-* @exception  SecurityException  if a security manager exists and its
+* @throws     SecurityException  if a security manager exists and its
 *             {@code checkSetFactory} method doesn't allow
 *             the operation.
 * @see        java.net.URL#URL(java.lang.String, java.lang.String,
 *             int, java.lang.String)
 * @see        java.net.URLStreamHandlerFactory
 * @serialField    ref String
 *
 * @serialField    hashCode int
 *
 */
+@java.io.Serial
 private static final ObjectStreamField[] serialPersistentFields = {
 new ObjectStreamField("protocol", String.class),
 new ObjectStreamField("host", String.class),
 new ObjectStreamField("port", int.class),
 new ObjectStreamField("authority", String.class),
 * @serialData the default write object value. When read back in,
 * the reader must ensure that calling getURLStreamHandler with
 * the protocol variable returns a valid URLStreamHandler and
 * throw an IOException if it does not.
 */
+@java.io.Serial
 private synchronized void writeObject(java.io.ObjectOutputStream s)
 throws IOException
 {
 s.defaultWriteObject(); // write the fields
 }
 /**
 * readObject is called to restore the state of the URL from the
 * stream.  It reads the components of the URL and finds the local
 * stream handler.
 */
+@java.io.Serial
 private synchronized void readObject(java.io.ObjectInputStream s)
 throws IOException, ClassNotFoundException {
 GetField gf = s.readFields();
 String protocol = (String)gf.get("protocol", null);
 if (getURLStreamHandler(protocol) == null) {
 * @return a newly created object from deserialized data
 *
 * @throws ObjectStreamException if a new object replacing this
 * object could not be created
 */
+@java.io.Serial
 private Object readResolve() throws ObjectStreamException {
 URLStreamHandler handler = null;
 // already been checked in readObject
 handler = getURLStreamHandler(tempState.getProtocol());
 replacementURL.setSerializedHashCode(tempState.getHashCode());
 resetState();
 return replacementURL;
 }
+boolean isBuiltinStreamHandler(URLStreamHandler handler) {
+return isBuiltinStreamHandler(handler.getClass().getName());
+}
 private boolean isBuiltinStreamHandler(String handlerClassName) {
 return (handlerClassName.startsWith(BUILTIN_HANDLERS_PREFIX));
 }
 private void resetState() {

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54696	0907dce4b90e
child 58679	9c3209ff7550