--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.base/share/classes/java/net/HostPortrange.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import java.net.*;
+import java.util.Formatter;
+import java.util.Locale;
+import sun.net.util.IPAddressUtil;
+
+/**
+ * Parses a string containing a host/domain name and port range
+ */
+class HostPortrange {
+
+ String hostname;
+ String scheme;
+ int[] portrange;
+
+ boolean wildcard;
+ boolean literal;
+ boolean ipv6, ipv4;
+ static final int PORT_MIN = 0;
+ static final int PORT_MAX = (1 << 16) -1;
+
+ boolean equals(HostPortrange that) {
+ return this.hostname.equals(that.hostname)
+ && this.portrange[0] == that.portrange[0]
+ && this.portrange[1] == that.portrange[1]
+ && this.wildcard == that.wildcard
+ && this.literal == that.literal;
+ }
+
+ public int hashCode() {
+ return hostname.hashCode() + portrange[0] + portrange[1];
+ }
+
+ HostPortrange(String scheme, String str) {
+ // Parse the host name. A name has up to three components, the
+ // hostname, a port number, or two numbers representing a port
+ // range. "www.sun.com:8080-9090" is a valid host name.
+
+ // With IPv6 an address can be 2010:836B:4179::836B:4179
+ // An IPv6 address needs to be enclose in []
+ // For ex: [2010:836B:4179::836B:4179]:8080-9090
+ // Refer to RFC 2732 for more information.
+
+ // first separate string into two fields: hoststr, portstr
+ String hoststr, portstr = null;
+ this.scheme = scheme;
+
+ // check for IPv6 address
+ if (str.charAt(0) == '[') {
+ ipv6 = literal = true;
+ int rb = str.indexOf(']');
+ if (rb != -1) {
+ hoststr = str.substring(1, rb);
+ } else {
+ throw new IllegalArgumentException("invalid IPv6 address: " + str);
+ }
+ int sep = str.indexOf(':', rb + 1);
+ if (sep != -1 && str.length() > sep) {
+ portstr = str.substring(sep + 1);
+ }
+ // need to normalize hoststr now
+ byte[] ip = IPAddressUtil.textToNumericFormatV6(hoststr);
+ if (ip == null) {
+ throw new IllegalArgumentException("illegal IPv6 address");
+ }
+ StringBuilder sb = new StringBuilder();
+ Formatter formatter = new Formatter(sb, Locale.US);
+ formatter.format("%02x%02x:%02x%02x:%02x%02x:%02x"
+ + "%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
+ ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7], ip[8],
+ ip[9], ip[10], ip[11], ip[12], ip[13], ip[14], ip[15]);
+ hostname = sb.toString();
+ } else {
+ // not IPv6 therefore ':' is the port separator
+
+ int sep = str.indexOf(':');
+ if (sep != -1 && str.length() > sep) {
+ hoststr = str.substring(0, sep);
+ portstr = str.substring(sep + 1);
+ } else {
+ hoststr = sep == -1 ? str : str.substring(0, sep);
+ }
+ // is this a domain wildcard specification?
+ if (hoststr.lastIndexOf('*') > 0) {
+ throw new IllegalArgumentException("invalid host wildcard specification");
+ } else if (hoststr.startsWith("*")) {
+ wildcard = true;
+ if (hoststr.equals("*")) {
+ hoststr = "";
+ } else if (hoststr.startsWith("*.")) {
+ hoststr = toLowerCase(hoststr.substring(1));
+ } else {
+ throw new IllegalArgumentException("invalid host wildcard specification");
+ }
+ } else {
+ // check if ipv4 (if rightmost label a number)
+ // The normal way to specify ipv4 is 4 decimal labels
+ // but actually three, two or single label formats valid also
+ // So, we recognise ipv4 by just testing the rightmost label
+ // being a number.
+ int lastdot = hoststr.lastIndexOf('.');
+ if (lastdot != -1 && (hoststr.length() > 1)) {
+ boolean ipv4 = true;
+
+ for (int i = lastdot + 1, len = hoststr.length(); i < len; i++) {
+ char c = hoststr.charAt(i);
+ if (c < '0' || c > '9') {
+ ipv4 = false;
+ break;
+ }
+ }
+ this.ipv4 = this.literal = ipv4;
+ if (ipv4) {
+ byte[] ip = IPAddressUtil.textToNumericFormatV4(hoststr);
+ if (ip == null) {
+ throw new IllegalArgumentException("illegal IPv4 address");
+ }
+ StringBuilder sb = new StringBuilder();
+ Formatter formatter = new Formatter(sb, Locale.US);
+ formatter.format("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+ hoststr = sb.toString();
+ } else {
+ // regular domain name
+ hoststr = toLowerCase(hoststr);
+ }
+ }
+ }
+ hostname = hoststr;
+ }
+
+ try {
+ portrange = parsePort(portstr);
+ } catch (Exception e) {
+ throw new IllegalArgumentException("invalid port range: " + portstr);
+ }
+ }
+
+ static final int CASE_DIFF = 'A' - 'a';
+
+ /**
+ * Convert to lower case, and check that all chars are ascii
+ * alphanumeric, '-' or '.' only.
+ */
+ static String toLowerCase(String s) {
+ int len = s.length();
+ StringBuilder sb = null;
+
+ for (int i=0; i<len; i++) {
+ char c = s.charAt(i);
+ if ((c >= 'a' && c <= 'z') || (c == '.')) {
+ if (sb != null)
+ sb.append(c);
+ } else if ((c >= '0' && c <= '9') || (c == '-')) {
+ if (sb != null)
+ sb.append(c);
+ } else if (c >= 'A' && c <= 'Z') {
+ if (sb == null) {
+ sb = new StringBuilder(len);
+ sb.append(s, 0, i);
+ }
+ sb.append((char)(c - CASE_DIFF));
+ } else {
+ throw new IllegalArgumentException("Invalid characters in hostname");
+ }
+ }
+ return sb == null ? s : sb.toString();
+ }
+
+
+ public boolean literal() {
+ return literal;
+ }
+
+ public boolean ipv4Literal() {
+ return ipv4;
+ }
+
+ public boolean ipv6Literal() {
+ return ipv6;
+ }
+
+ public String hostname() {
+ return hostname;
+ }
+
+ public int[] portrange() {
+ return portrange;
+ }
+
+ /**
+ * returns true if the hostname part started with *
+ * hostname returns the remaining part of the host component
+ * eg "*.foo.com" -> ".foo.com" or "*" -> ""
+ *
+ * @return
+ */
+ public boolean wildcard() {
+ return wildcard;
+ }
+
+ // these shouldn't leak outside the implementation
+ static final int[] HTTP_PORT = {80, 80};
+ static final int[] HTTPS_PORT = {443, 443};
+ static final int[] NO_PORT = {-1, -1};
+
+ int[] defaultPort() {
+ if (scheme.equals("http")) {
+ return HTTP_PORT;
+ } else if (scheme.equals("https")) {
+ return HTTPS_PORT;
+ }
+ return NO_PORT;
+ }
+
+ int[] parsePort(String port)
+ {
+
+ if (port == null || port.equals("")) {
+ return defaultPort();
+ }
+
+ if (port.equals("*")) {
+ return new int[] {PORT_MIN, PORT_MAX};
+ }
+
+ try {
+ int dash = port.indexOf('-');
+
+ if (dash == -1) {
+ int p = Integer.parseInt(port);
+ return new int[] {p, p};
+ } else {
+ String low = port.substring(0, dash);
+ String high = port.substring(dash+1);
+ int l,h;
+
+ if (low.equals("")) {
+ l = PORT_MIN;
+ } else {
+ l = Integer.parseInt(low);
+ }
+
+ if (high.equals("")) {
+ h = PORT_MAX;
+ } else {
+ h = Integer.parseInt(high);
+ }
+ if (l < 0 || h < 0 || h<l) {
+ return defaultPort();
+ }
+ return new int[] {l, h};
+ }
+ } catch (IllegalArgumentException e) {
+ return defaultPort();
+ }
+ }
+}