jdk/src/share/classes/java/net/URLStreamHandler.java
author juh
Tue, 30 Jul 2013 11:04:19 -0700
changeset 19069 1d9cb0d080e3
parent 16055 311a101eb72c
child 22064 e3c4398c54cd
permissions -rw-r--r--
8021833: javadoc cleanup in java.net Summary: <code> and <tt> converted to {@code }; package.html to package-info.java Reviewed-by: darcy, chegar
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
     2
 * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.net;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.io.IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.io.InputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.io.File;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.io.OutputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.util.Hashtable;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import sun.net.util.IPAddressUtil;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import sun.net.www.ParseUtil;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
/**
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    37
 * The abstract class {@code URLStreamHandler} is the common
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * superclass for all stream protocol handlers. A stream protocol
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 * handler knows how to make a connection for a particular protocol
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    40
 * type, such as {@code http} or {@code https}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * <p>
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    42
 * In most cases, an instance of a {@code URLStreamHandler}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * subclass is not created directly by an application. Rather, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * first time a protocol name is encountered when constructing a
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    45
 * {@code URL}, the appropriate stream protocol handler is
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * automatically loaded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 * @author  James Gosling
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 * @see     java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 * @since   JDK1.0
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
public abstract class URLStreamHandler {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
     * Opens a connection to the object referenced by the
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    55
     * {@code URL} argument.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
     * This method should be overridden by a subclass.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
     * <p>If for the handler's protocol (such as HTTP or JAR), there
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
     * exists a public, specialized URLConnection subclass belonging
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
     * to one of the following packages or one of their subpackages:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
     * java.lang, java.io, java.util, java.net, the connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
     * returned will be of that subclass. For example, for HTTP an
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
     * HttpURLConnection will be returned, and for JAR a
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
     * JarURLConnection will be returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
     * @param      u   the URL that this connects to.
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    67
     * @return     a {@code URLConnection} object for the {@code URL}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
     * @exception  IOException  if an I/O error occurs while opening the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
     *               connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    abstract protected URLConnection openConnection(URL u) throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
     * Same as openConnection(URL), except that the connection will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
     * made through the specified proxy; Protocol handlers that do not
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
     * support proxying will ignore the proxy parameter and make a
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
     * normal connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
     * Calling this method preempts the system's default ProxySelector
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
     * settings.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     * @param      u   the URL that this connects to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
     * @param      p   the proxy through which the connection will be made.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
     *                 If direct connection is desired, Proxy.NO_PROXY
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     *                 should be specified.
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
    86
     * @return     a {@code URLConnection} object for the {@code URL}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * @exception  IOException  if an I/O error occurs while opening the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     *               connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * @exception  IllegalArgumentException if either u or p is null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
     *               or p has the wrong type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
     * @exception  UnsupportedOperationException if the subclass that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     *               implements the protocol doesn't support this method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
     * @since      1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
    protected URLConnection openConnection(URL u, Proxy p) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
        throw new UnsupportedOperationException("Method not implemented.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
    /**
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   100
     * Parses the string representation of a {@code URL} into a
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   101
     * {@code URL} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
     * If there is any inherited context, then it has already been
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   104
     * copied into the {@code URL} argument.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
     * <p>
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   106
     * The {@code parseURL} method of {@code URLStreamHandler}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
     * parses the string representation as if it were an
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   108
     * {@code http} specification. Most URL protocol families have a
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
     * similar parsing. A stream protocol handler for a protocol that has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
     * a different syntax must override this routine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
     *
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   112
     * @param   u       the {@code URL} to receive the result of parsing
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
     *                  the spec.
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   114
     * @param   spec    the {@code String} representing the URL that
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
     *                  must be parsed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
     * @param   start   the character index at which to begin parsing. This is
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   117
     *                  just past the '{@code :}' (if there is one) that
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
     *                  specifies the determination of the protocol name.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
     * @param   limit   the character position to stop parsing at. This is the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
     *                  end of the string or the position of the
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   121
     *                  "{@code #}" character, if present. All information
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
     *                  after the sharp sign indicates an anchor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
    protected void parseURL(URL u, String spec, int start, int limit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
        // These fields may receive context content if this was relative URL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
        String protocol = u.getProtocol();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
        String authority = u.getAuthority();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
        String userInfo = u.getUserInfo();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
        String host = u.getHost();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
        int port = u.getPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
        String path = u.getPath();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
        String query = u.getQuery();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
        // This field has already been parsed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
        String ref = u.getRef();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
        boolean isRelPath = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
        boolean queryOnly = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
// FIX: should not assume query if opaque
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
        // Strip off the query part
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
        if (start < limit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
            int queryStart = spec.indexOf('?');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
            queryOnly = queryStart == start;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
            if ((queryStart != -1) && (queryStart < limit)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
                query = spec.substring(queryStart+1, limit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
                if (limit > queryStart)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
                    limit = queryStart;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
                spec = spec.substring(0, queryStart);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
        int i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
        // Parse the authority part if any
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
        boolean isUNCName = (start <= limit - 4) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
                        (spec.charAt(start) == '/') &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
                        (spec.charAt(start + 1) == '/') &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
                        (spec.charAt(start + 2) == '/') &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
                        (spec.charAt(start + 3) == '/');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
        if (!isUNCName && (start <= limit - 2) && (spec.charAt(start) == '/') &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
            (spec.charAt(start + 1) == '/')) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
            start += 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
            i = spec.indexOf('/', start);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
            if (i < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
                i = spec.indexOf('?', start);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
                if (i < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
                    i = limit;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
            host = authority = spec.substring(start, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
            int ind = authority.indexOf('@');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
            if (ind != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
                userInfo = authority.substring(0, ind);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
                host = authority.substring(ind+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
                userInfo = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
            if (host != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
                // If the host is surrounded by [ and ] then its an IPv6
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
                // literal address as specified in RFC2732
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
                if (host.length()>0 && (host.charAt(0) == '[')) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
                    if ((ind = host.indexOf(']')) > 2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
                        String nhost = host ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
                        host = nhost.substring(0,ind+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
                        if (!IPAddressUtil.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
                            isIPv6LiteralAddress(host.substring(1, ind))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
                            throw new IllegalArgumentException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
                                "Invalid host: "+ host);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
                        port = -1 ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
                        if (nhost.length() > ind+1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
                            if (nhost.charAt(ind+1) == ':') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
                                ++ind ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
                                // port can be null according to RFC2396
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
                                if (nhost.length() > (ind + 1)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
                                    port = Integer.parseInt(nhost.substring(ind+1));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
                                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
                            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
                                throw new IllegalArgumentException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
                                    "Invalid authority field: " + authority);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
                        throw new IllegalArgumentException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
                            "Invalid authority field: " + authority);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
                    ind = host.indexOf(':');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
                    port = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
                    if (ind >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
                        // port can be null according to RFC2396
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
                        if (host.length() > (ind + 1)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
                            port = Integer.parseInt(host.substring(ind + 1));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
                        host = host.substring(0, ind);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
                host = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
            if (port < -1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
                throw new IllegalArgumentException("Invalid port number :" +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
                                                   port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
            start = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
            // If the authority is defined then the path is defined by the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
            // spec only; See RFC 2396 Section 5.2.4.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
            if (authority != null && authority.length() > 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
                path = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
        if (host == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
            host = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
        // Parse the file path if any
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
        if (start < limit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
            if (spec.charAt(start) == '/') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
                path = spec.substring(start, limit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
            } else if (path != null && path.length() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
                isRelPath = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
                int ind = path.lastIndexOf('/');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
                String seperator = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
                if (ind == -1 && authority != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
                    seperator = "/";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
                path = path.substring(0, ind + 1) + seperator +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
                         spec.substring(start, limit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
                String seperator = (authority != null) ? "/" : "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
                path = seperator + spec.substring(start, limit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
        } else if (queryOnly && path != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
            int ind = path.lastIndexOf('/');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
            if (ind < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
                ind = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
            path = path.substring(0, ind) + "/";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
        if (path == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
            path = "";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
        if (isRelPath) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
            // Remove embedded /./
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
            while ((i = path.indexOf("/./")) >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
                path = path.substring(0, i) + path.substring(i + 2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
            // Remove embedded /../ if possible
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
            i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
            while ((i = path.indexOf("/../", i)) >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
                /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
                 * A "/../" will cancel the previous segment and itself,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
                 * unless that segment is a "/../" itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
                 * i.e. "/a/b/../c" becomes "/a/c"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
                 * but "/../../a" should stay unchanged
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
                 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
                if (i > 0 && (limit = path.lastIndexOf('/', i - 1)) >= 0 &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
                    (path.indexOf("/../", limit) != 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
                    path = path.substring(0, limit) + path.substring(i + 3);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
                    i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
                    i = i + 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
            // Remove trailing .. if possible
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
            while (path.endsWith("/..")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
                i = path.indexOf("/..");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
                if ((limit = path.lastIndexOf('/', i - 1)) >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
                    path = path.substring(0, limit+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
            // Remove starting .
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
            if (path.startsWith("./") && path.length() > 2)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
                path = path.substring(2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
            // Remove trailing .
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
            if (path.endsWith("/."))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
                path = path.substring(0, path.length() -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
        setURL(u, protocol, host, port, authority, userInfo, path, query, ref);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
     * Returns the default port for a URL parsed by this handler. This method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
     * is meant to be overidden by handlers with default port numbers.
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   310
     * @return the default port for a {@code URL} parsed by this handler.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
    protected int getDefaultPort() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
     * Provides the default equals calculation. May be overidden by handlers
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
     * for other protocols that have different requirements for equals().
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
     * This method requires that none of its arguments is null. This is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
     * guaranteed by the fact that it is only called by java.net.URL class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
     * @param u1 a URL object
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
     * @param u2 a URL object
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   324
     * @return {@code true} if the two urls are
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
     * considered equal, ie. they refer to the same
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
     * fragment in the same file.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
    protected boolean equals(URL u1, URL u2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
        String ref1 = u1.getRef();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        String ref2 = u2.getRef();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
        return (ref1 == ref2 || (ref1 != null && ref1.equals(ref2))) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
               sameFile(u1, u2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
     * Provides the default hash calculation. May be overidden by handlers for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
     * other protocols that have different requirements for hashCode
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
     * calculation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
     * @param u a URL object
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   341
     * @return an {@code int} suitable for hash table indexing
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
    protected int hashCode(URL u) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
        int h = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
        // Generate the protocol part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
        String protocol = u.getProtocol();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
        if (protocol != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
            h += protocol.hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
        // Generate the host part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
        InetAddress addr = getHostAddress(u);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
        if (addr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
            h += addr.hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
            String host = u.getHost();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
            if (host != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
                h += host.toLowerCase().hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
        // Generate the file part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
        String file = u.getFile();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
        if (file != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
            h += file.hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
        // Generate the port part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
        if (u.getPort() == -1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
            h += getDefaultPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
        else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
            h += u.getPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
        // Generate the ref part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
        String ref = u.getRef();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
        if (ref != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
            h += ref.hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
        return h;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
     * Compare two urls to see whether they refer to the same file,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
     * i.e., having the same protocol, host, port, and path.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
     * This method requires that none of its arguments is null. This is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
     * guaranteed by the fact that it is only called indirectly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
     * by java.net.URL class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
     * @param u1 a URL object
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
     * @param u2 a URL object
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
     * @return true if u1 and u2 refer to the same file
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
    protected boolean sameFile(URL u1, URL u2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
        // Compare the protocols.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
        if (!((u1.getProtocol() == u2.getProtocol()) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
              (u1.getProtocol() != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
               u1.getProtocol().equalsIgnoreCase(u2.getProtocol()))))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
        // Compare the files.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
        if (!(u1.getFile() == u2.getFile() ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
              (u1.getFile() != null && u1.getFile().equals(u2.getFile()))))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
        // Compare the ports.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
        int port1, port2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
        port1 = (u1.getPort() != -1) ? u1.getPort() : u1.handler.getDefaultPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
        port2 = (u2.getPort() != -1) ? u2.getPort() : u2.handler.getDefaultPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
        if (port1 != port2)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
        // Compare the hosts.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
        if (!hostsEqual(u1, u2))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
     * Get the IP address of our host. An empty host field or a DNS failure
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
     * will result in a null return.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
     * @param u a URL object
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   423
     * @return an {@code InetAddress} representing the host
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
     * IP address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
    protected synchronized InetAddress getHostAddress(URL u) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
        if (u.hostAddress != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
            return u.hostAddress;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
        String host = u.getHost();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
        if (host == null || host.equals("")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
                u.hostAddress = InetAddress.getByName(host);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
            } catch (UnknownHostException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
                return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
            } catch (SecurityException se) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
                return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
        return u.hostAddress;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
     * Compares the host components of two URLs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
     * @param u1 the URL of the first host to compare
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
     * @param u2 the URL of the second host to compare
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   450
     * @return  {@code true} if and only if they
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   451
     * are equal, {@code false} otherwise.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
    protected boolean hostsEqual(URL u1, URL u2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
        InetAddress a1 = getHostAddress(u1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
        InetAddress a2 = getHostAddress(u2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
        // if we have internet address for both, compare them
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
        if (a1 != null && a2 != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
            return a1.equals(a2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
        // else, if both have host names, compare them
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
        } else if (u1.getHost() != null && u2.getHost() != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
            return u1.getHost().equalsIgnoreCase(u2.getHost());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
         else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
            return u1.getHost() == null && u2.getHost() == null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
    /**
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   468
     * Converts a {@code URL} of a specific protocol to a
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   469
     * {@code String}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
     * @param   u   the URL.
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   472
     * @return  a string representation of the {@code URL} argument.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
    protected String toExternalForm(URL u) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
        // pre-compute length of StringBuffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
        int len = u.getProtocol().length() + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
        if (u.getAuthority() != null && u.getAuthority().length() > 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
            len += 2 + u.getAuthority().length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
        if (u.getPath() != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
            len += u.getPath().length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
        if (u.getQuery() != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
            len += 1 + u.getQuery().length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
        if (u.getRef() != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
            len += 1 + u.getRef().length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
        StringBuffer result = new StringBuffer(len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
        result.append(u.getProtocol());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
        result.append(":");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
        if (u.getAuthority() != null && u.getAuthority().length() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
            result.append("//");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
            result.append(u.getAuthority());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
        if (u.getPath() != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
            result.append(u.getPath());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
        if (u.getQuery() != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
            result.append('?');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
            result.append(u.getQuery());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
        if (u.getRef() != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
            result.append("#");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
            result.append(u.getRef());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
        return result.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
    /**
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   511
     * Sets the fields of the {@code URL} argument to the indicated values.
16055
311a101eb72c 4880778: URL final class has protected methods
jzavgren
parents: 14342
diff changeset
   512
     * Only classes derived from URLStreamHandler are able
311a101eb72c 4880778: URL final class has protected methods
jzavgren
parents: 14342
diff changeset
   513
     * to use this method to set the values of the URL fields.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
     * @param   u         the URL to modify.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
     * @param   protocol  the protocol name.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
     * @param   host      the remote host value for the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
     * @param   port      the port on the remote machine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
     * @param   authority the authority part for the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
     * @param   userInfo the userInfo part of the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
     * @param   path      the path component of the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
     * @param   query     the query part for the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
     * @param   ref       the reference.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
     * @exception       SecurityException       if the protocol handler of the URL is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
     *                                  different from this one
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
     * @see     java.net.URL#set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
       protected void setURL(URL u, String protocol, String host, int port,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
                             String authority, String userInfo, String path,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
                             String query, String ref) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
        if (this != u.handler) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
            throw new SecurityException("handler for url different from " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
                                        "this handler");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
        // ensure that no one can reset the protocol on a given URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
        u.set(u.getProtocol(), host, port, authority, userInfo, path, query, ref);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
    /**
19069
1d9cb0d080e3 8021833: javadoc cleanup in java.net
juh
parents: 16055
diff changeset
   541
     * Sets the fields of the {@code URL} argument to the indicated values.
16055
311a101eb72c 4880778: URL final class has protected methods
jzavgren
parents: 14342
diff changeset
   542
     * Only classes derived from URLStreamHandler are able
311a101eb72c 4880778: URL final class has protected methods
jzavgren
parents: 14342
diff changeset
   543
     * to use this method to set the values of the URL fields.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
     * @param   u         the URL to modify.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
     * @param   protocol  the protocol name. This value is ignored since 1.2.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
     * @param   host      the remote host value for the URL.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
     * @param   port      the port on the remote machine.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
     * @param   file      the file.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
     * @param   ref       the reference.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
     * @exception       SecurityException       if the protocol handler of the URL is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
     *                                  different from this one
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
     * @deprecated Use setURL(URL, String, String, int, String, String, String,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
     *             String);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
    protected void setURL(URL u, String protocol, String host, int port,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
                          String file, String ref) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
         * Only old URL handlers call this, so assume that the host
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
         * field might contain "user:passwd@host". Fix as necessary.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
        String authority = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
        String userInfo = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
        if (host != null && host.length() != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
            authority = (port == -1) ? host : host + ":" + port;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
            int at = host.lastIndexOf('@');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
            if (at != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
                userInfo = host.substring(0, at);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
                host = host.substring(at+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
         * Assume file might contain query part. Fix as necessary.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
        String path = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
        String query = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
        if (file != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
            int q = file.lastIndexOf('?');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
            if (q != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
                query = file.substring(q+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
                path = file.substring(0, q);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
            } else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
                path = file;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
        setURL(u, protocol, host, port, authority, userInfo, path, query, ref);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
}