/** * Create an IPv6 network from its String representation. For example * "1234:5678:abcd:0:0:0:0:0/64" or "2001::ff/128". * * @param string string representation * @return IPv6 network */ public IPv6Network fromString(String string) { if (string.indexOf('/') == -1) { throw new IllegalArgumentException("Expected format is network-address/prefix-length"); } final String networkAddressString = parseNetworkAddress(string); int prefixLength = parsePrefixLength(string); IPv6Address networkAddress = new IPv6Address().fromString(networkAddressString); return new IPv6Network(networkAddress, new IPv6NetworkMask(prefixLength)); }
public int numberOfTrailingOnes() { // count trailing ones in "value" by counting the trailing zeroes in "value + 1" final IPv6Address plusOne = this.add(1); return plusOne.getLowBits() == 0 ? Long.numberOfTrailingZeros(plusOne.getHighBits()) + 64 : Long.numberOfTrailingZeros(plusOne.getLowBits()); }
private String expandShortNotation(String string) { if (!string.contains("::")) { return string; } else if (string.equals("::")) { return generateZeroes(8); } else { final int numberOfColons = countOccurrences(string, ':'); if (string.startsWith("::")) { return string.replace("::", generateZeroes((7 + 2) - numberOfColons)); } else if (string.endsWith("::")) { return string.replace("::", ":" + generateZeroes((7 + 2) - numberOfColons)); } else { return string.replace("::", ":" + generateZeroes((7 + 2 - 1) - numberOfColons)); } } }
/** * Subtraction. Will never underflow, but wraps around when the lowest * ip address has been reached. * * @param value value to subtract * @return new IPv6 address */ public IPv6Address subtract(int value) { final long newLowBits = lowBits - value; if (value >= 0) { if (isLessThanUnsigned(lowBits, newLowBits)) { // oops, we subtracted something positive and the result is bigger -> overflow detected (carry over one bit from high to low) return new IPv6Address(highBits - 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } else { if (isLessThanUnsigned(newLowBits, lowBits)) { // oops, we subtracted something negative and the result is smaller -> overflow detected (carry over one bit from low to high) return new IPv6Address(highBits + 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } }
/** * Addition. Will never overflow, but wraps around when the highest ip * address has been reached. * * @param value value to add * @return new IPv6 address */ public IPv6Address add(int value) { final long newLowBits = lowBits + value; if (value >= 0) { if (isLessThanUnsigned(newLowBits, lowBits)) { // oops, we added something positive and the result is smaller -> overflow detected (carry over one bit from low to high) return new IPv6Address(highBits + 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } else { if (isLessThanUnsigned(lowBits, newLowBits)) { // oops, we added something negative and the result is bigger -> overflow detected (carry over one bit from high to low) return new IPv6Address(highBits - 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } }
/** * Addition. Will never overflow, but wraps around when the highest ip * address has been reached. * * @param value value to add * @return new IPv6 address */ public IPv6Address add(int value) { final long newLowBits = lowBits + value; if (value >= 0) { if (isLessThanUnsigned(newLowBits, lowBits)) { // oops, we added something positive and the result is smaller -> overflow detected (carry over one bit from low to high) return new IPv6Address(highBits + 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } else { if (isLessThanUnsigned(lowBits, newLowBits)) { // oops, we added something negative and the result is bigger -> overflow detected (carry over one bit from high to low) return new IPv6Address(highBits - 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } }
/** * Subtraction. Will never underflow, but wraps around when the lowest * ip address has been reached. * * @param value value to subtract * @return new IPv6 address */ public IPv6Address subtract(int value) { final long newLowBits = lowBits - value; if (value >= 0) { if (isLessThanUnsigned(lowBits, newLowBits)) { // oops, we subtracted something positive and the result is bigger -> overflow detected (carry over one bit from high to low) return new IPv6Address(highBits - 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } else { if (isLessThanUnsigned(newLowBits, lowBits)) { // oops, we subtracted something negative and the result is smaller -> overflow detected (carry over one bit from low to high) return new IPv6Address(highBits + 1, newLowBits); } else { // no overflow return new IPv6Address(highBits, newLowBits); } } }
/** * Mask the address with the given network mask. * * @param networkMask network mask * @return an address of which the last 128 - * networkMask.asPrefixLength() bits are zero */ public IPv6Address maskWithNetworkMask(final IPv6NetworkMask networkMask) { if (networkMask.asPrefixLength() == 128) { return this; } else if (networkMask.asPrefixLength() == 64) { return new IPv6Address(this.highBits, 0); } else if (networkMask.asPrefixLength() == 0) { return new IPv6Address(0, 0); } else if (networkMask.asPrefixLength() > 64) { // apply mask on low bits only final int remainingPrefixLength = networkMask.asPrefixLength() - 64; return new IPv6Address(this.highBits, this.lowBits & (0xFFFFFFFFFFFFFFFFL << (64 - remainingPrefixLength))); } else { // apply mask on high bits, low bits completely 0 return new IPv6Address(this.highBits & (0xFFFFFFFFFFFFFFFFL << (64 - networkMask.asPrefixLength())), 0); } }
/** * Mask the address with the given network mask. * * @param networkMask network mask * @return an address of which the last 128 - * networkMask.asPrefixLength() bits are zero */ public IPv6Address maskWithNetworkMask(final IPv6NetworkMask networkMask) { if (networkMask.asPrefixLength() == 128) { return this; } else if (networkMask.asPrefixLength() == 64) { return new IPv6Address(this.highBits, 0); } else if (networkMask.asPrefixLength() == 0) { return new IPv6Address(0, 0); } else if (networkMask.asPrefixLength() > 64) { // apply mask on low bits only final int remainingPrefixLength = networkMask.asPrefixLength() - 64; return new IPv6Address(this.highBits, this.lowBits & (0xFFFFFFFFFFFFFFFFL << (64 - remainingPrefixLength))); } else { // apply mask on high bits, low bits completely 0 return new IPv6Address(this.highBits & (0xFFFFFFFFFFFFFFFFL << (64 - networkMask.asPrefixLength())), 0); } }
/** * Calculate the maximum address with the given network mask. * * @param networkMask network mask * @return an address of which the last 128 - * networkMask.asPrefixLength() bits are one */ public IPv6Address maximumAddressWithNetworkMask(final IPv6NetworkMask networkMask) { if (networkMask.asPrefixLength() == 128) { return this; } else if (networkMask.asPrefixLength() == 64) { return new IPv6Address(this.highBits, 0xFFFFFFFFFFFFFFFFL); } else if (networkMask.asPrefixLength() > 64) { // apply mask on low bits only final int remainingPrefixLength = networkMask.asPrefixLength() - 64; return new IPv6Address(this.highBits, this.lowBits | (0xFFFFFFFFFFFFFFFFL >>> remainingPrefixLength)); } else { // apply mask on high bits, low bits completely 1 return new IPv6Address(this.highBits | (0xFFFFFFFFFFFFFFFFL >>> networkMask.asPrefixLength()), 0xFFFFFFFFFFFFFFFFL); } }
/** * Calculate the maximum address with the given network mask. * * @param networkMask network mask * @return an address of which the last 128 - * networkMask.asPrefixLength() bits are one */ public IPv6Address maximumAddressWithNetworkMask(final IPv6NetworkMask networkMask) { if (networkMask.asPrefixLength() == 128) { return this; } else if (networkMask.asPrefixLength() == 64) { return new IPv6Address(this.highBits, 0xFFFFFFFFFFFFFFFFL); } else if (networkMask.asPrefixLength() > 64) { // apply mask on low bits only final int remainingPrefixLength = networkMask.asPrefixLength() - 64; return new IPv6Address(this.highBits, this.lowBits | (0xFFFFFFFFFFFFFFFFL >>> remainingPrefixLength)); } else { // apply mask on high bits, low bits completely 1 return new IPv6Address(this.highBits | (0xFFFFFFFFFFFFFFFFL >>> networkMask.asPrefixLength()), 0xFFFFFFFFFFFFFFFFL); } }
/** * Create an IPv6 address from its String representation. For example * "1234:5678:abcd:0000:9876:3210:ffff:ffff" or "2001::ff" or even "::". * IPv4-Mapped IPv6 addresses such as "::ffff:123.456.123.456" are also * supported. * * @param string string representation * @return IPv6 address */ public IPv6Address fromString(String string) { if (string == null) { throw new IllegalArgumentException("can not parse [null]"); } final String withoutScope = removeScope(string); final String withoutIPv4MappedNotation = rewriteIPv4MappedNotation(withoutScope); final String longNotation = expandShortNotation(withoutIPv4MappedNotation); final long[] longs = tryParseStringArrayIntoLongArray(string, longNotation); return mergeLongArrayIntoIPv6Address(longs); }
/** * Create an IPv6 address from its String representation. For example * "1234:5678:abcd:0000:9876:3210:ffff:ffff" or "2001::ff" or even "::". * IPv4-Mapped IPv6 addresses such as "::ffff:123.456.123.456" are also * supported. * * @param string string representation * @return IPv6 address */ public IPv6Address fromString(String string) { if (string == null) { throw new IllegalArgumentException("can not parse [null]"); } final String withoutScope = removeScope(string); final String withoutIPv4MappedNotation = rewriteIPv4MappedNotation(withoutScope); final String longNotation = expandShortNotation(withoutIPv4MappedNotation); final long[] longs = tryParseStringArrayIntoLongArray(string, longNotation); return mergeLongArrayIntoIPv6Address(longs); }
private String expandShortNotation(String string) { if (!string.contains("::")) { return string; } else if (string.equals("::")) { return generateZeroes(8); } else { final int numberOfColons = countOccurrences(string, ':'); if (string.startsWith("::")) { return string.replace("::", generateZeroes((7 + 2) - numberOfColons)); } else if (string.endsWith("::")) { return string.replace("::", ":" + generateZeroes((7 + 2) - numberOfColons)); } else { return string.replace("::", ":" + generateZeroes((7 + 2 - 1) - numberOfColons)); } } }
/** * Create an IPv6 network from its String representation. For example * "1234:5678:abcd:0:0:0:0:0/64" or "2001::ff/128". * * @param string string representation * @return IPv6 network */ public IPv6Network fromString(String string) { if (string.indexOf('/') == -1) { throw new IllegalArgumentException("Expected format is network-address/prefix-length"); } final String networkAddressString = parseNetworkAddress(string); int prefixLength = parsePrefixLength(string); IPv6Address networkAddress = new IPv6Address().fromString(networkAddressString); return new IPv6Network(networkAddress, new IPv6NetworkMask(prefixLength)); }
public static String getIPV6Address(String ip) { return new IPv6Address().fromString(ip).toString(); }
public static String getIPV6Address(String ip) { return new IPv6Address().fromString(ip).toString(); }
int[] startAndLengthOfLongestRunOfZeroes() { int longestConsecutiveZeroes = 0; int longestConsecutiveZeroesPos = -1; short[] shorts = toShortArray(); for (int pos = 0; pos < shorts.length; pos++) { int consecutiveZeroesAtCurrentPos = countConsecutiveZeroes(shorts, pos); if (consecutiveZeroesAtCurrentPos > longestConsecutiveZeroes) { longestConsecutiveZeroes = consecutiveZeroesAtCurrentPos; longestConsecutiveZeroesPos = pos; } } return new int[]{longestConsecutiveZeroesPos, longestConsecutiveZeroes}; }
public IPv6Address asAddress() { if (prefixLength == 128) { return new IPv6Address(0xFFFFFFFFFFFFFFFFL, 0xFFFFFFFFFFFFFFFFL); } else if (prefixLength == 64) { return new IPv6Address(0xFFFFFFFFFFFFFFFFL, 0L); } else if (prefixLength > 64) { final int remainingPrefixLength = prefixLength - 64; return new IPv6Address(0xFFFFFFFFFFFFFFFFL, (0xFFFFFFFFFFFFFFFFL << (64 - remainingPrefixLength))); } else { return new IPv6Address(0xFFFFFFFFFFFFFFFFL << (64 - prefixLength), 0); } } }
int[] startAndLengthOfLongestRunOfZeroes() { int longestConsecutiveZeroes = 0; int longestConsecutiveZeroesPos = -1; short[] shorts = toShortArray(); for (int pos = 0; pos < shorts.length; pos++) { int consecutiveZeroesAtCurrentPos = countConsecutiveZeroes(shorts, pos); if (consecutiveZeroesAtCurrentPos > longestConsecutiveZeroes) { longestConsecutiveZeroes = consecutiveZeroesAtCurrentPos; longestConsecutiveZeroesPos = pos; } } return new int[]{longestConsecutiveZeroesPos, longestConsecutiveZeroes}; }