/** * 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)); }
/** * 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)); }
/** * 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); } }
/** * 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); } }
/** * 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); } }
public static String getIPV6Address(String ip) { return new IPv6Address().fromString(ip).toString(); }
public static String getIPV6Address(String ip) { return new IPv6Address().fromString(ip).toString(); }
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); } } }
private IPv6Address mergeLongArrayIntoIPv6Address(long[] longs) { long high = 0L; long low = 0L; for (int i = 0; i < longs.length; i++) { if (inHighRange(i)) { high |= (longs[i] << ((longs.length - i - 1) * 16)); } else { low |= (longs[i] << ((longs.length - i - 1) * 16)); } } return new IPv6Address(high, low); }
public int numberOfLeadingOnes() { // count leading ones in "value" by counting leading zeroes in "~ value" final IPv6Address flipped = new IPv6Address(~this.highBits, ~this.lowBits); return flipped.numberOfLeadingZeroes(); }
private IPv6Address mergeLongArrayIntoIPv6Address(long[] longs) { long high = 0L; long low = 0L; for (int i = 0; i < longs.length; i++) { if (inHighRange(i)) { high |= (longs[i] << ((longs.length - i - 1) * 16)); } else { low |= (longs[i] << ((longs.length - i - 1) * 16)); } } return new IPv6Address(high, low); }
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); } } }
public int numberOfLeadingOnes() { // count leading ones in "value" by counting leading zeroes in "~ value" final IPv6Address flipped = new IPv6Address(~this.highBits, ~this.lowBits); return flipped.numberOfLeadingZeroes(); }