Java tutorial
/* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package io.netty.util; import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.SocketUtils; import io.netty.util.internal.StringUtil; import io.netty.util.internal.SystemPropertyUtil; import io.netty.util.internal.logging.InternalLogger; import io.netty.util.internal.logging.InternalLoggerFactory; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.NetworkInterface; import java.net.SocketException; import java.net.UnknownHostException; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import static io.netty.util.AsciiString.indexOf; /** * A class that holds a number of network-related constants. * <p/> * This class borrowed some of its methods from a modified fork of the * <a href="http://svn.apache.org/repos/asf/harmony/enhanced/java/branches/java6/classlib/modules/luni/ * src/main/java/org/apache/harmony/luni/util/Inet6Util.java">Inet6Util class</a> which was part of Apache Harmony. */ public final class NetUtil { /** * The {@link Inet4Address} that represents the IPv4 loopback address '127.0.0.1' */ public static final Inet4Address LOCALHOST4; /** * The {@link Inet6Address} that represents the IPv6 loopback address '::1' */ public static final Inet6Address LOCALHOST6; /** * The {@link InetAddress} that represents the loopback address. If IPv6 stack is available, it will refer to * {@link #LOCALHOST6}. Otherwise, {@link #LOCALHOST4}. */ public static final InetAddress LOCALHOST; /** * The loopback {@link NetworkInterface} of the current machine */ public static final NetworkInterface LOOPBACK_IF; /** * The SOMAXCONN value of the current machine. If failed to get the value, {@code 200} is used as a * default value for Windows or {@code 128} for others. */ public static final int SOMAXCONN; /** * This defines how many words (represented as ints) are needed to represent an IPv6 address */ private static final int IPV6_WORD_COUNT = 8; /** * The maximum number of characters for an IPV6 string with no scope */ private static final int IPV6_MAX_CHAR_COUNT = 39; /** * Number of bytes needed to represent and IPV6 value */ private static final int IPV6_BYTE_COUNT = 16; /** * Maximum amount of value adding characters in between IPV6 separators */ private static final int IPV6_MAX_CHAR_BETWEEN_SEPARATOR = 4; /** * Minimum number of separators that must be present in an IPv6 string */ private static final int IPV6_MIN_SEPARATORS = 2; /** * Maximum number of separators that must be present in an IPv6 string */ private static final int IPV6_MAX_SEPARATORS = 8; /** * Maximum amount of value adding characters in between IPV4 separators */ private static final int IPV4_MAX_CHAR_BETWEEN_SEPARATOR = 3; /** * Number of separators that must be present in an IPv4 string */ private static final int IPV4_SEPARATORS = 3; /** * {@code true} if IPv4 should be used even if the system supports both IPv4 and IPv6. */ private static final boolean IPV4_PREFERRED = SystemPropertyUtil.getBoolean("java.net.preferIPv4Stack", false); /** * {@code true} if an IPv6 address should be preferred when a host has both an IPv4 address and an IPv6 address. */ private static final boolean IPV6_ADDRESSES_PREFERRED = SystemPropertyUtil .getBoolean("java.net.preferIPv6Addresses", false); /** * The logger being used by this class */ private static final InternalLogger logger = InternalLoggerFactory.getInstance(NetUtil.class); static { logger.debug("-Djava.net.preferIPv4Stack: {}", IPV4_PREFERRED); logger.debug("-Djava.net.preferIPv6Addresses: {}", IPV6_ADDRESSES_PREFERRED); byte[] LOCALHOST4_BYTES = { 127, 0, 0, 1 }; byte[] LOCALHOST6_BYTES = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; // Create IPv4 loopback address. Inet4Address localhost4 = null; try { localhost4 = (Inet4Address) InetAddress.getByAddress("localhost", LOCALHOST4_BYTES); } catch (Exception e) { // We should not get here as long as the length of the address is correct. PlatformDependent.throwException(e); } LOCALHOST4 = localhost4; // Create IPv6 loopback address. Inet6Address localhost6 = null; try { localhost6 = (Inet6Address) InetAddress.getByAddress("localhost", LOCALHOST6_BYTES); } catch (Exception e) { // We should not get here as long as the length of the address is correct. PlatformDependent.throwException(e); } LOCALHOST6 = localhost6; // Retrieve the list of available network interfaces. List<NetworkInterface> ifaces = new ArrayList<NetworkInterface>(); try { Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); if (interfaces != null) { while (interfaces.hasMoreElements()) { NetworkInterface iface = interfaces.nextElement(); // Use the interface with proper INET addresses only. if (SocketUtils.addressesFromNetworkInterface(iface).hasMoreElements()) { ifaces.add(iface); } } } } catch (SocketException e) { logger.warn("Failed to retrieve the list of available network interfaces", e); } // Find the first loopback interface available from its INET address (127.0.0.1 or ::1) // Note that we do not use NetworkInterface.isLoopback() in the first place because it takes long time // on a certain environment. (e.g. Windows with -Djava.net.preferIPv4Stack=true) NetworkInterface loopbackIface = null; InetAddress loopbackAddr = null; loop: for (NetworkInterface iface : ifaces) { for (Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface); i .hasMoreElements();) { InetAddress addr = i.nextElement(); if (addr.isLoopbackAddress()) { // Found loopbackIface = iface; loopbackAddr = addr; break loop; } } } // If failed to find the loopback interface from its INET address, fall back to isLoopback(). if (loopbackIface == null) { try { for (NetworkInterface iface : ifaces) { if (iface.isLoopback()) { Enumeration<InetAddress> i = SocketUtils.addressesFromNetworkInterface(iface); if (i.hasMoreElements()) { // Found the one with INET address. loopbackIface = iface; loopbackAddr = i.nextElement(); break; } } } if (loopbackIface == null) { logger.warn("Failed to find the loopback interface"); } } catch (SocketException e) { logger.warn("Failed to find the loopback interface", e); } } if (loopbackIface != null) { // Found the loopback interface with an INET address. logger.debug("Loopback interface: {} ({}, {})", loopbackIface.getName(), loopbackIface.getDisplayName(), loopbackAddr.getHostAddress()); } else { // Could not find the loopback interface, but we can't leave LOCALHOST as null. // Use LOCALHOST6 or LOCALHOST4, preferably the IPv6 one. if (loopbackAddr == null) { try { if (NetworkInterface.getByInetAddress(LOCALHOST6) != null) { logger.debug("Using hard-coded IPv6 localhost address: {}", localhost6); loopbackAddr = localhost6; } } catch (Exception e) { // Ignore } finally { if (loopbackAddr == null) { logger.debug("Using hard-coded IPv4 localhost address: {}", localhost4); loopbackAddr = localhost4; } } } } LOOPBACK_IF = loopbackIface; LOCALHOST = loopbackAddr; // As a SecurityManager may prevent reading the somaxconn file we wrap this in a privileged block. // // See https://github.com/netty/netty/issues/3680 SOMAXCONN = AccessController.doPrivileged(new PrivilegedAction<Integer>() { @Override public Integer run() { // Determine the default somaxconn (server socket backlog) value of the platform. // The known defaults: // - Windows NT Server 4.0+: 200 // - Linux and Mac OS X: 128 int somaxconn = PlatformDependent.isWindows() ? 200 : 128; File file = new File("/proc/sys/net/core/somaxconn"); BufferedReader in = null; try { // file.exists() may throw a SecurityException if a SecurityManager is used, so execute it in the // try / catch block. // See https://github.com/netty/netty/issues/4936 if (file.exists()) { in = new BufferedReader(new FileReader(file)); somaxconn = Integer.parseInt(in.readLine()); if (logger.isDebugEnabled()) { logger.debug("{}: {}", file, somaxconn); } } else { // Try to get from sysctl Integer tmp = null; if (SystemPropertyUtil.getBoolean("io.netty.net.somaxconn.trySysctl", false)) { tmp = sysctlGetInt("kern.ipc.somaxconn"); if (tmp == null) { tmp = sysctlGetInt("kern.ipc.soacceptqueue"); if (tmp != null) { somaxconn = tmp; } } else { somaxconn = tmp; } } if (tmp == null) { logger.debug("Failed to get SOMAXCONN from sysctl and file {}. Default: {}", file, somaxconn); } } } catch (Exception e) { logger.debug("Failed to get SOMAXCONN from sysctl and file {}. Default: {}", file, somaxconn, e); } finally { if (in != null) { try { in.close(); } catch (Exception e) { // Ignored. } } } return somaxconn; } }); } /** * This will execute <a href ="https://www.freebsd.org/cgi/man.cgi?sysctl(8)">sysctl</a> with the {@code sysctlKey} * which is expected to return the numeric value for for {@code sysctlKey}. * @param sysctlKey The key which the return value corresponds to. * @return The <a href ="https://www.freebsd.org/cgi/man.cgi?sysctl(8)">sysctl</a> value for {@code sysctlKey}. */ private static Integer sysctlGetInt(String sysctlKey) throws IOException { Process process = new ProcessBuilder("sysctl", sysctlKey).start(); try { InputStream is = process.getInputStream(); InputStreamReader isr = new InputStreamReader(is); BufferedReader br = new BufferedReader(isr); try { String line = br.readLine(); if (line.startsWith(sysctlKey)) { for (int i = line.length() - 1; i > sysctlKey.length(); --i) { if (!Character.isDigit(line.charAt(i))) { return Integer.valueOf(line.substring(i + 1)); } } } return null; } finally { br.close(); } } finally { if (process != null) { process.destroy(); } } } /** * Returns {@code true} if IPv4 should be used even if the system supports both IPv4 and IPv6. Setting this * property to {@code true} will disable IPv6 support. The default value of this property is {@code false}. * * @see <a href="https://docs.oracle.com/javase/8/docs/api/java/net/doc-files/net-properties.html">Java SE * networking properties</a> */ public static boolean isIpV4StackPreferred() { return IPV4_PREFERRED; } /** * Returns {@code true} if an IPv6 address should be preferred when a host has both an IPv4 address and an IPv6 * address. The default value of this property is {@code false}. * * @see <a href="https://docs.oracle.com/javase/8/docs/api/java/net/doc-files/net-properties.html">Java SE * networking properties</a> */ public static boolean isIpV6AddressesPreferred() { return IPV6_ADDRESSES_PREFERRED; } /** * Creates an byte[] based on an ipAddressString. No error handling is performed here. */ public static byte[] createByteArrayFromIpAddressString(String ipAddressString) { if (isValidIpV4Address(ipAddressString)) { return validIpV4ToBytes(ipAddressString); } if (isValidIpV6Address(ipAddressString)) { if (ipAddressString.charAt(0) == '[') { ipAddressString = ipAddressString.substring(1, ipAddressString.length() - 1); } int percentPos = ipAddressString.indexOf('%'); if (percentPos >= 0) { ipAddressString = ipAddressString.substring(0, percentPos); } return getIPv6ByName(ipAddressString, true); } return null; } private static int decimalDigit(String str, int pos) { return str.charAt(pos) - '0'; } private static byte ipv4WordToByte(String ip, int from, int toExclusive) { int ret = decimalDigit(ip, from); from++; if (from == toExclusive) { return (byte) ret; } ret = ret * 10 + decimalDigit(ip, from); from++; if (from == toExclusive) { return (byte) ret; } return (byte) (ret * 10 + decimalDigit(ip, from)); } // visible for tests static byte[] validIpV4ToBytes(String ip) { int i; return new byte[] { ipv4WordToByte(ip, 0, i = ip.indexOf('.', 1)), ipv4WordToByte(ip, i + 1, i = ip.indexOf('.', i + 2)), ipv4WordToByte(ip, i + 1, i = ip.indexOf('.', i + 2)), ipv4WordToByte(ip, i + 1, ip.length()) }; } /** * Converts a 32-bit integer into an IPv4 address. */ public static String intToIpAddress(int i) { StringBuilder buf = new StringBuilder(15); buf.append(i >> 24 & 0xff); buf.append('.'); buf.append(i >> 16 & 0xff); buf.append('.'); buf.append(i >> 8 & 0xff); buf.append('.'); buf.append(i & 0xff); return buf.toString(); } /** * Converts 4-byte or 16-byte data into an IPv4 or IPv6 string respectively. * * @throws IllegalArgumentException * if {@code length} is not {@code 4} nor {@code 16} */ public static String bytesToIpAddress(byte[] bytes) { return bytesToIpAddress(bytes, 0, bytes.length); } /** * Converts 4-byte or 16-byte data into an IPv4 or IPv6 string respectively. * * @throws IllegalArgumentException * if {@code length} is not {@code 4} nor {@code 16} */ public static String bytesToIpAddress(byte[] bytes, int offset, int length) { switch (length) { case 4: { return new StringBuilder(15).append(bytes[offset] & 0xff).append('.').append(bytes[offset + 1] & 0xff) .append('.').append(bytes[offset + 2] & 0xff).append('.').append(bytes[offset + 3] & 0xff) .toString(); } case 16: return toAddressString(bytes, offset, false); default: throw new IllegalArgumentException("length: " + length + " (expected: 4 or 16)"); } } public static boolean isValidIpV6Address(String ip) { return isValidIpV6Address((CharSequence) ip); } public static boolean isValidIpV6Address(CharSequence ip) { int end = ip.length(); if (end < 2) { return false; } // strip "[]" int start; char c = ip.charAt(0); if (c == '[') { end--; if (ip.charAt(end) != ']') { // must have a close ] return false; } start = 1; c = ip.charAt(1); } else { start = 0; } int colons; int compressBegin; if (c == ':') { // an IPv6 address can start with "::" or with a number if (ip.charAt(start + 1) != ':') { return false; } colons = 2; compressBegin = start; start += 2; } else { colons = 0; compressBegin = -1; } int wordLen = 0; loop: for (int i = start; i < end; i++) { c = ip.charAt(i); if (isValidHexChar(c)) { if (wordLen < 4) { wordLen++; continue; } return false; } switch (c) { case ':': if (colons > 7) { return false; } if (ip.charAt(i - 1) == ':') { if (compressBegin >= 0) { return false; } compressBegin = i - 1; } else { wordLen = 0; } colons++; break; case '.': // case for the last 32-bits represented as IPv4 x:x:x:x:x:x:d.d.d.d // check a normal case (6 single colons) if (compressBegin < 0 && colons != 6 || // a special case ::1:2:3:4:5:d.d.d.d allows 7 colons with an // IPv4 ending, otherwise 7 :'s is bad (colons == 7 && compressBegin >= start || colons > 7)) { return false; } // Verify this address is of the correct structure to contain an IPv4 address. // It must be IPv4-Mapped or IPv4-Compatible // (see https://tools.ietf.org/html/rfc4291#section-2.5.5). int ipv4Start = i - wordLen; int j = ipv4Start - 2; // index of character before the previous ':'. if (isValidIPv4MappedChar(ip.charAt(j))) { if (!isValidIPv4MappedChar(ip.charAt(j - 1)) || !isValidIPv4MappedChar(ip.charAt(j - 2)) || !isValidIPv4MappedChar(ip.charAt(j - 3))) { return false; } j -= 5; } for (; j >= start; --j) { char tmpChar = ip.charAt(j); if (tmpChar != '0' && tmpChar != ':') { return false; } } // 7 - is minimum IPv4 address length int ipv4End = indexOf(ip, '%', ipv4Start + 7); if (ipv4End < 0) { ipv4End = end; } return isValidIpV4Address(ip, ipv4Start, ipv4End); case '%': // strip the interface name/index after the percent sign end = i; break loop; default: return false; } } // normal case without compression if (compressBegin < 0) { return colons == 7 && wordLen > 0; } return compressBegin + 2 == end || // 8 colons is valid only if compression in start or end wordLen > 0 && (colons < 8 || compressBegin <= start); } private static boolean isValidIpV4Word(CharSequence word, int from, int toExclusive) { int len = toExclusive - from; char c0, c1, c2; if (len < 1 || len > 3 || (c0 = word.charAt(from)) < '0') { return false; } if (len == 3) { return (c1 = word.charAt(from + 1)) >= '0' && (c2 = word.charAt(from + 2)) >= '0' && (c0 <= '1' && c1 <= '9' && c2 <= '9' || c0 == '2' && c1 <= '5' && (c2 <= '5' || c1 < '5' && c2 <= '9')); } return c0 <= '9' && (len == 1 || isValidNumericChar(word.charAt(from + 1))); } private static boolean isValidHexChar(char c) { return c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a' && c <= 'f'; } private static boolean isValidNumericChar(char c) { return c >= '0' && c <= '9'; } private static boolean isValidIPv4MappedChar(char c) { return c == 'f' || c == 'F'; } private static boolean isValidIPv4MappedSeparators(byte b0, byte b1, boolean mustBeZero) { // We allow IPv4 Mapped (https://tools.ietf.org/html/rfc4291#section-2.5.5.1) // and IPv4 compatible (https://tools.ietf.org/html/rfc4291#section-2.5.5.1). // The IPv4 compatible is deprecated, but it allows parsing of plain IPv4 addressed into IPv6-Mapped addresses. return b0 == b1 && (b0 == 0 || !mustBeZero && b1 == -1); } private static boolean isValidIPv4Mapped(byte[] bytes, int currentIndex, int compressBegin, int compressLength) { final boolean mustBeZero = compressBegin + compressLength >= 14; return currentIndex <= 12 && currentIndex >= 2 && (!mustBeZero || compressBegin < 12) && isValidIPv4MappedSeparators(bytes[currentIndex - 1], bytes[currentIndex - 2], mustBeZero) && PlatformDependent.isZero(bytes, 0, currentIndex - 3); } /** * Takes a {@link CharSequence} and parses it to see if it is a valid IPV4 address. * * @return true, if the string represents an IPV4 address in dotted * notation, false otherwise */ public static boolean isValidIpV4Address(CharSequence ip) { return isValidIpV4Address(ip, 0, ip.length()); } /** * Takes a {@link String} and parses it to see if it is a valid IPV4 address. * * @return true, if the string represents an IPV4 address in dotted * notation, false otherwise */ public static boolean isValidIpV4Address(String ip) { return isValidIpV4Address(ip, 0, ip.length()); } private static boolean isValidIpV4Address(CharSequence ip, int from, int toExcluded) { return ip instanceof String ? isValidIpV4Address((String) ip, from, toExcluded) : ip instanceof AsciiString ? isValidIpV4Address((AsciiString) ip, from, toExcluded) : isValidIpV4Address0(ip, from, toExcluded); } @SuppressWarnings("DuplicateBooleanBranch") private static boolean isValidIpV4Address(String ip, int from, int toExcluded) { int len = toExcluded - from; int i; return len <= 15 && len >= 7 && (i = ip.indexOf('.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) && (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && isValidIpV4Word(ip, i + 1, toExcluded); } @SuppressWarnings("DuplicateBooleanBranch") private static boolean isValidIpV4Address(AsciiString ip, int from, int toExcluded) { int len = toExcluded - from; int i; return len <= 15 && len >= 7 && (i = ip.indexOf('.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) && (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && (i = ip.indexOf('.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && isValidIpV4Word(ip, i + 1, toExcluded); } @SuppressWarnings("DuplicateBooleanBranch") private static boolean isValidIpV4Address0(CharSequence ip, int from, int toExcluded) { int len = toExcluded - from; int i; return len <= 15 && len >= 7 && (i = indexOf(ip, '.', from + 1)) > 0 && isValidIpV4Word(ip, from, i) && (i = indexOf(ip, '.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && (i = indexOf(ip, '.', from = i + 2)) > 0 && isValidIpV4Word(ip, from - 1, i) && isValidIpV4Word(ip, i + 1, toExcluded); } /** * Returns the {@link Inet6Address} representation of a {@link CharSequence} IP address. * <p> * This method will treat all IPv4 type addresses as "IPv4 mapped" (see {@link #getByName(CharSequence, boolean)}) * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address} * @return {@link Inet6Address} representation of the {@code ip} or {@code null} if not a valid IP address. */ public static Inet6Address getByName(CharSequence ip) { return getByName(ip, true); } /** * Returns the {@link Inet6Address} representation of a {@link CharSequence} IP address. * <p> * The {@code ipv4Mapped} parameter specifies how IPv4 addresses should be treated. * "IPv4 mapped" format as * defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a> is supported. * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address} * @param ipv4Mapped * <ul> * <li>{@code true} To allow IPv4 mapped inputs to be translated into {@link Inet6Address}</li> * <li>{@code false} Consider IPv4 mapped addresses as invalid.</li> * </ul> * @return {@link Inet6Address} representation of the {@code ip} or {@code null} if not a valid IP address. */ public static Inet6Address getByName(CharSequence ip, boolean ipv4Mapped) { byte[] bytes = getIPv6ByName(ip, ipv4Mapped); if (bytes == null) { return null; } try { return Inet6Address.getByAddress(null, bytes, -1); } catch (UnknownHostException e) { throw new RuntimeException(e); // Should never happen } } /** * Returns the byte array representation of a {@link CharSequence} IP address. * <p> * The {@code ipv4Mapped} parameter specifies how IPv4 addresses should be treated. * "IPv4 mapped" format as * defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a> is supported. * @param ip {@link CharSequence} IP address to be converted to a {@link Inet6Address} * @param ipv4Mapped * <ul> * <li>{@code true} To allow IPv4 mapped inputs to be translated into {@link Inet6Address}</li> * <li>{@code false} Consider IPv4 mapped addresses as invalid.</li> * </ul> * @return byte array representation of the {@code ip} or {@code null} if not a valid IP address. */ private static byte[] getIPv6ByName(CharSequence ip, boolean ipv4Mapped) { final byte[] bytes = new byte[IPV6_BYTE_COUNT]; final int ipLength = ip.length(); int compressBegin = 0; int compressLength = 0; int currentIndex = 0; int value = 0; int begin = -1; int i = 0; int ipv6Separators = 0; int ipv4Separators = 0; int tmp; boolean needsShift = false; for (; i < ipLength; ++i) { final char c = ip.charAt(i); switch (c) { case ':': ++ipv6Separators; if (i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR || ipv4Separators > 0 || ipv6Separators > IPV6_MAX_SEPARATORS || currentIndex + 1 >= bytes.length) { return null; } value <<= (IPV6_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2; if (compressLength > 0) { compressLength -= 2; } // The value integer holds at most 4 bytes from right (most significant) to left (least significant). // The following bit shifting is used to extract and re-order the individual bytes to achieve a // left (most significant) to right (least significant) ordering. bytes[currentIndex++] = (byte) (((value & 0xf) << 4) | ((value >> 4) & 0xf)); bytes[currentIndex++] = (byte) ((((value >> 8) & 0xf) << 4) | ((value >> 12) & 0xf)); tmp = i + 1; if (tmp < ipLength && ip.charAt(tmp) == ':') { ++tmp; if (compressBegin != 0 || (tmp < ipLength && ip.charAt(tmp) == ':')) { return null; } ++ipv6Separators; needsShift = ipv6Separators == 2 && value == 0; compressBegin = currentIndex; compressLength = bytes.length - compressBegin - 2; ++i; } value = 0; begin = -1; break; case '.': ++ipv4Separators; tmp = i - begin; // tmp is the length of the current segment. if (tmp > IPV4_MAX_CHAR_BETWEEN_SEPARATOR || begin < 0 || ipv4Separators > IPV4_SEPARATORS || (ipv6Separators > 0 && (currentIndex + compressLength < 12)) || i + 1 >= ipLength || currentIndex >= bytes.length || ipv4Separators == 1 && // We also parse pure IPv4 addresses as IPv4-Mapped for ease of use. ((!ipv4Mapped || currentIndex != 0 && !isValidIPv4Mapped(bytes, currentIndex, compressBegin, compressLength)) || (tmp == 3 && (!isValidNumericChar(ip.charAt(i - 1)) || !isValidNumericChar(ip.charAt(i - 2)) || !isValidNumericChar(ip.charAt(i - 3))) || tmp == 2 && (!isValidNumericChar(ip.charAt(i - 1)) || !isValidNumericChar(ip.charAt(i - 2))) || tmp == 1 && !isValidNumericChar(ip.charAt(i - 1))))) { return null; } value <<= (IPV4_MAX_CHAR_BETWEEN_SEPARATOR - tmp) << 2; // The value integer holds at most 3 bytes from right (most significant) to left (least significant). // The following bit shifting is to restructure the bytes to be left (most significant) to // right (least significant) while also accounting for each IPv4 digit is base 10. begin = (value & 0xf) * 100 + ((value >> 4) & 0xf) * 10 + ((value >> 8) & 0xf); if (begin < 0 || begin > 255) { return null; } bytes[currentIndex++] = (byte) begin; value = 0; begin = -1; break; default: if (!isValidHexChar(c) || (ipv4Separators > 0 && !isValidNumericChar(c))) { return null; } if (begin < 0) { begin = i; } else if (i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR) { return null; } // The value is treated as a sort of array of numbers because we are dealing with // at most 4 consecutive bytes we can use bit shifting to accomplish this. // The most significant byte will be encountered first, and reside in the right most // position of the following integer value += StringUtil.decodeHexNibble(c) << ((i - begin) << 2); break; } } final boolean isCompressed = compressBegin > 0; // Finish up last set of data that was accumulated in the loop (or before the loop) if (ipv4Separators > 0) { if (begin > 0 && i - begin > IPV4_MAX_CHAR_BETWEEN_SEPARATOR || ipv4Separators != IPV4_SEPARATORS || currentIndex >= bytes.length) { return null; } if (ipv6Separators == 0) { compressLength = 12; } else if (ipv6Separators >= IPV6_MIN_SEPARATORS && (!isCompressed && (ipv6Separators == 6 && ip.charAt(0) != ':') || isCompressed && (ipv6Separators < IPV6_MAX_SEPARATORS && (ip.charAt(0) != ':' || compressBegin <= 2)))) { compressLength -= 2; } else { return null; } value <<= (IPV4_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2; // The value integer holds at most 3 bytes from right (most significant) to left (least significant). // The following bit shifting is to restructure the bytes to be left (most significant) to // right (least significant) while also accounting for each IPv4 digit is base 10. begin = (value & 0xf) * 100 + ((value >> 4) & 0xf) * 10 + ((value >> 8) & 0xf); if (begin < 0 || begin > 255) { return null; } bytes[currentIndex++] = (byte) begin; } else { tmp = ipLength - 1; if (begin > 0 && i - begin > IPV6_MAX_CHAR_BETWEEN_SEPARATOR || ipv6Separators < IPV6_MIN_SEPARATORS || !isCompressed && (ipv6Separators + 1 != IPV6_MAX_SEPARATORS || ip.charAt(0) == ':' || ip.charAt(tmp) == ':') || isCompressed && (ipv6Separators > IPV6_MAX_SEPARATORS || (ipv6Separators == IPV6_MAX_SEPARATORS && (compressBegin <= 2 && ip.charAt(0) != ':' || compressBegin >= 14 && ip.charAt(tmp) != ':'))) || currentIndex + 1 >= bytes.length || begin < 0 && ip.charAt(tmp - 1) != ':' || compressBegin > 2 && ip.charAt(0) == ':') { return null; } if (begin >= 0 && i - begin <= IPV6_MAX_CHAR_BETWEEN_SEPARATOR) { value <<= (IPV6_MAX_CHAR_BETWEEN_SEPARATOR - (i - begin)) << 2; } // The value integer holds at most 4 bytes from right (most significant) to left (least significant). // The following bit shifting is used to extract and re-order the individual bytes to achieve a // left (most significant) to right (least significant) ordering. bytes[currentIndex++] = (byte) (((value & 0xf) << 4) | ((value >> 4) & 0xf)); bytes[currentIndex++] = (byte) ((((value >> 8) & 0xf) << 4) | ((value >> 12) & 0xf)); } i = currentIndex + compressLength; if (needsShift || i >= bytes.length) { // Right shift array if (i >= bytes.length) { ++compressBegin; } for (i = currentIndex; i < bytes.length; ++i) { for (begin = bytes.length - 1; begin >= compressBegin; --begin) { bytes[begin] = bytes[begin - 1]; } bytes[begin] = 0; ++compressBegin; } } else { // Selectively move elements for (i = 0; i < compressLength; ++i) { begin = i + compressBegin; currentIndex = begin + compressLength; if (currentIndex < bytes.length) { bytes[currentIndex] = bytes[begin]; bytes[begin] = 0; } else { break; } } } if (ipv4Separators > 0) { // We only support IPv4-Mapped addresses [1] because IPv4-Compatible addresses are deprecated [2]. // [1] https://tools.ietf.org/html/rfc4291#section-2.5.5.2 // [2] https://tools.ietf.org/html/rfc4291#section-2.5.5.1 bytes[10] = bytes[11] = (byte) 0xff; } return bytes; } /** * Returns the {@link String} representation of an {@link InetSocketAddress}. * <p> * The output does not include Scope ID. * @param addr {@link InetSocketAddress} to be converted to an address string * @return {@code String} containing the text-formatted IP address */ public static String toSocketAddressString(InetSocketAddress addr) { String port = String.valueOf(addr.getPort()); final StringBuilder sb; if (addr.isUnresolved()) { String hostname = getHostname(addr); sb = newSocketAddressStringBuilder(hostname, port, !isValidIpV6Address(hostname)); } else { InetAddress address = addr.getAddress(); String hostString = toAddressString(address); sb = newSocketAddressStringBuilder(hostString, port, address instanceof Inet4Address); } return sb.append(':').append(port).toString(); } /** * Returns the {@link String} representation of a host port combo. */ public static String toSocketAddressString(String host, int port) { String portStr = String.valueOf(port); return newSocketAddressStringBuilder(host, portStr, !isValidIpV6Address(host)).append(':').append(portStr) .toString(); } private static StringBuilder newSocketAddressStringBuilder(String host, String port, boolean ipv4) { int hostLen = host.length(); if (ipv4) { // Need to include enough space for hostString:port. return new StringBuilder(hostLen + 1 + port.length()).append(host); } // Need to include enough space for [hostString]:port. StringBuilder stringBuilder = new StringBuilder(hostLen + 3 + port.length()); if (hostLen > 1 && host.charAt(0) == '[' && host.charAt(hostLen - 1) == ']') { return stringBuilder.append(host); } return stringBuilder.append('[').append(host).append(']'); } /** * Returns the {@link String} representation of an {@link InetAddress}. * <ul> * <li>Inet4Address results are identical to {@link InetAddress#getHostAddress()}</li> * <li>Inet6Address results adhere to * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li> * </ul> * <p> * The output does not include Scope ID. * @param ip {@link InetAddress} to be converted to an address string * @return {@code String} containing the text-formatted IP address */ public static String toAddressString(InetAddress ip) { return toAddressString(ip, false); } /** * Returns the {@link String} representation of an {@link InetAddress}. * <ul> * <li>Inet4Address results are identical to {@link InetAddress#getHostAddress()}</li> * <li>Inet6Address results adhere to * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a> if * {@code ipv4Mapped} is false. If {@code ipv4Mapped} is true then "IPv4 mapped" format * from <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a> will be supported. * The compressed result will always obey the compression rules defined in * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li> * </ul> * <p> * The output does not include Scope ID. * @param ip {@link InetAddress} to be converted to an address string * @param ipv4Mapped * <ul> * <li>{@code true} to stray from strict rfc 5952 and support the "IPv4 mapped" format * defined in <a href="http://tools.ietf.org/html/rfc4291#section-2.5.5">rfc 4291 section 2</a> while still * following the updated guidelines in * <a href="http://tools.ietf.org/html/rfc5952#section-4">rfc 5952 section 4</a></li> * <li>{@code false} to strictly follow rfc 5952</li> * </ul> * @return {@code String} containing the text-formatted IP address */ public static String toAddressString(InetAddress ip, boolean ipv4Mapped) { if (ip instanceof Inet4Address) { return ip.getHostAddress(); } if (!(ip instanceof Inet6Address)) { throw new IllegalArgumentException("Unhandled type: " + ip); } return toAddressString(ip.getAddress(), 0, ipv4Mapped); } private static String toAddressString(byte[] bytes, int offset, boolean ipv4Mapped) { final int[] words = new int[IPV6_WORD_COUNT]; int i; final int end = offset + words.length; for (i = offset; i < end; ++i) { words[i] = ((bytes[i << 1] & 0xff) << 8) | (bytes[(i << 1) + 1] & 0xff); } // Find longest run of 0s, tie goes to first found instance int currentStart = -1; int currentLength; int shortestStart = -1; int shortestLength = 0; for (i = 0; i < words.length; ++i) { if (words[i] == 0) { if (currentStart < 0) { currentStart = i; } } else if (currentStart >= 0) { currentLength = i - currentStart; if (currentLength > shortestLength) { shortestStart = currentStart; shortestLength = currentLength; } currentStart = -1; } } // If the array ends on a streak of zeros, make sure we account for it if (currentStart >= 0) { currentLength = i - currentStart; if (currentLength > shortestLength) { shortestStart = currentStart; shortestLength = currentLength; } } // Ignore the longest streak if it is only 1 long if (shortestLength == 1) { shortestLength = 0; shortestStart = -1; } // Translate to string taking into account longest consecutive 0s final int shortestEnd = shortestStart + shortestLength; final StringBuilder b = new StringBuilder(IPV6_MAX_CHAR_COUNT); if (shortestEnd < 0) { // Optimization when there is no compressing needed b.append(Integer.toHexString(words[0])); for (i = 1; i < words.length; ++i) { b.append(':'); b.append(Integer.toHexString(words[i])); } } else { // General case that can handle compressing (and not compressing) // Loop unroll the first index (so we don't constantly check i==0 cases in loop) final boolean isIpv4Mapped; if (inRangeEndExclusive(0, shortestStart, shortestEnd)) { b.append("::"); isIpv4Mapped = ipv4Mapped && (shortestEnd == 5 && words[5] == 0xffff); } else { b.append(Integer.toHexString(words[0])); isIpv4Mapped = false; } for (i = 1; i < words.length; ++i) { if (!inRangeEndExclusive(i, shortestStart, shortestEnd)) { if (!inRangeEndExclusive(i - 1, shortestStart, shortestEnd)) { // If the last index was not part of the shortened sequence if (!isIpv4Mapped || i == 6) { b.append(':'); } else { b.append('.'); } } if (isIpv4Mapped && i > 5) { b.append(words[i] >> 8); b.append('.'); b.append(words[i] & 0xff); } else { b.append(Integer.toHexString(words[i])); } } else if (!inRangeEndExclusive(i - 1, shortestStart, shortestEnd)) { // If we are in the shortened sequence and the last index was not b.append("::"); } } } return b.toString(); } /** * Returns {@link InetSocketAddress#getHostString()} if Java >= 7, * or {@link InetSocketAddress#getHostName()} otherwise. * @param addr The address * @return the host string */ public static String getHostname(InetSocketAddress addr) { return PlatformDependent.javaVersion() >= 7 ? addr.getHostString() : addr.getHostName(); } /** * Does a range check on {@code value} if is within {@code start} (inclusive) and {@code end} (exclusive). * @param value The value to checked if is within {@code start} (inclusive) and {@code end} (exclusive) * @param start The start of the range (inclusive) * @param end The end of the range (exclusive) * @return * <ul> * <li>{@code true} if {@code value} if is within {@code start} (inclusive) and {@code end} (exclusive)</li> * <li>{@code false} otherwise</li> * </ul> */ private static boolean inRangeEndExclusive(int value, int start, int end) { return value >= start && value < end; } /** * A constructor to stop this class being constructed. */ private NetUtil() { // Unused } }