package net.onrc.onos.apps.sdnip;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import com.google.common.net.InetAddresses;
/**
* Represents an IP prefix.
* <p/>
* It is made up of an IP address and a number of significant bits in the
* prefix (i.e. the size of the network part of the address).
* E.g. {@code 192.168.0.0/16}.
* <p/>
* Currently only IPv4 is supported, so a prefix length can be up to 32 bits.
*/
public class Prefix {
/**
* The length of addresses this class can represent prefixes of, in bytes.
*/
public static final int ADDRESS_LENGTH_BYTES = 4;
/**
* The length of addresses this class can represent prefixes of, in bits.
*/
public static final int MAX_PREFIX_LENGTH = Byte.SIZE * ADDRESS_LENGTH_BYTES;
public static final int MIN_PREFIX_LENGTH = 0;
private static final int BINARY_RADIX = 2;
private final int prefixLength;
private final byte[] address;
private final String binaryString;
// For verifying the arguments and pretty printing
private final InetAddress inetAddress;
/**
* Class constructor, taking an byte array representing and IP address and
* a prefix length.
* <p/>
* The valid values for addr and prefixLength are bounded by
* {@link #ADDRESS_LENGTH_BYTES}.
* <p/>
* A valid addr array satisfies
* {@code addr.length == }{@value #ADDRESS_LENGTH_BYTES}.
* <p/>
* A valid prefixLength satisfies
* {@code (prefixLength >= 0 && prefixLength <=} {@link Byte#SIZE}
* {@code * }{@value #ADDRESS_LENGTH_BYTES}{@code )}.
*
* @param addr a byte array representing the address
* @param prefixLength length of the prefix of the specified address
*/
public Prefix(byte[] addr, int prefixLength) {
if (addr == null || addr.length != ADDRESS_LENGTH_BYTES ||
prefixLength < MIN_PREFIX_LENGTH ||
prefixLength > MAX_PREFIX_LENGTH) {
throw new IllegalArgumentException();
}
address = canonicalizeAddress(addr, prefixLength);
this.prefixLength = prefixLength;
binaryString = createBinaryString();
try {
inetAddress = InetAddress.getByAddress(address);
} catch (UnknownHostException e) {
throw new IllegalArgumentException("Couldn't parse IP address", e);
}
}
/**
* Class constructor, taking an address in String format and a prefix
* length. The address must be in dot-notation form (e.g. {@code 0.0.0.0}).
*
* @param strAddress a String representing the address
* @param prefixLength length of the prefix of the specified address
*/
public Prefix(String strAddress, int prefixLength) {
byte[] addr = null;
addr = InetAddresses.forString(strAddress).getAddress();
if (addr == null || addr.length != ADDRESS_LENGTH_BYTES ||
prefixLength < MIN_PREFIX_LENGTH ||
prefixLength > MAX_PREFIX_LENGTH) {
throw new IllegalArgumentException();
}
address = canonicalizeAddress(addr, prefixLength);
this.prefixLength = prefixLength;
binaryString = createBinaryString();
try {
inetAddress = InetAddress.getByAddress(address);
} catch (UnknownHostException e) {
throw new IllegalArgumentException("Couldn't parse IP address", e);
}
}
/**
* This method takes a byte array passed in by the user and ensures it
* conforms to the format we want. The byte array can contain anything,
* but only some of the bits are significant. The bits after
* prefixLengthValue are not significant, and this method will zero them
* out in order to ensure there is a canonical representation for each
* prefix. This simplifies the equals and hashcode methods, because once we
* have a canonical byte array representation we can simply compare byte
* arrays to test equality.
*
* @param addressValue the byte array to canonicalize
* @param prefixLengthValue The length of the prefix. Bits up to and including
* prefixLength are significant, bits following prefixLength are not
* significant and will be zeroed out.
* @return the canonicalized representation of the prefix
*/
private byte[] canonicalizeAddress(byte[] addressValue,
int prefixLengthValue) {
byte[] result = new byte[addressValue.length];
if (prefixLengthValue == 0) {
for (int i = 0; i < ADDRESS_LENGTH_BYTES; i++) {
result[i] = 0;
}
return result;
}
result = Arrays.copyOf(addressValue, addressValue.length);
//Set all bytes after the end of the prefix to 0
int lastByteIndex = (prefixLengthValue - 1) / Byte.SIZE;
for (int i = lastByteIndex; i < ADDRESS_LENGTH_BYTES; i++) {
result[i] = 0;
}
byte lastByte = addressValue[lastByteIndex];
byte mask = 0;
byte msb = (byte) 0x80;
int lastBit = (prefixLengthValue - 1) % Byte.SIZE;
for (int i = 0; i < Byte.SIZE; i++) {
if (i <= lastBit) {
mask |= (msb >> i);
}
}
result[lastByteIndex] = (byte) (lastByte & mask);
return result;
}
/**
* Creates the binary string representation of the prefix.
* The strings length is equal to prefixLength.
*
* @return the binary string representation
*/
private String createBinaryString() {
if (prefixLength == 0) {
return "";
}
StringBuilder result = new StringBuilder(prefixLength);
for (int i = 0; i < address.length; i++) {
byte b = address[i];
for (int j = 0; j < Byte.SIZE; j++) {
byte mask = (byte) (0x80 >>> j);
result.append(((b & mask) == 0) ? "0" : "1");
if (i * Byte.SIZE + j == prefixLength - 1) {
return result.toString();
}
}
}
return result.toString();
}
/**
* Gets the length of the prefix of the address.
*
* @return the prefix length
*/
public int getPrefixLength() {
return prefixLength;
}
/**
* Gets the address.
*
* @return the address as a byte array
*/
public byte[] getAddress() {
return Arrays.copyOf(address, address.length);
}
/**
* Gets the InetAddress.
*
* @return the inetAddress
*/
public InetAddress getInetAddress() {
return inetAddress;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Prefix)) {
return false;
}
Prefix otherPrefix = (Prefix) other;
return (Arrays.equals(address, otherPrefix.address)) &&
(prefixLength == otherPrefix.prefixLength);
}
@Override
public int hashCode() {
int hash = 17;
hash = 31 * hash + prefixLength;
hash = 31 * hash + Arrays.hashCode(address);
return hash;
}
@Override
public String toString() {
return inetAddress.getHostAddress() + "/" + prefixLength;
}
/**
* Gets a binary string representation of the prefix.
*
* @return a binary string representation
*/
public String toBinaryString() {
return binaryString;
}
/**
* Creates a Prefix object from a binary string.
* <p/>
* This is the reverse operation of {@link Prefix#toBinaryString()}. It
* takes a binary string (a String containing only '0' and '1'
* characters) and parses it to create a corresponding Prefix object.
*
* @param binaryString the binary string to convert to Prefix
* @return a Prefix object representing the same prefix as the input string
*/
public static Prefix fromBinaryString(String binaryString) {
if (binaryString.length() > MAX_PREFIX_LENGTH) {
throw new IllegalArgumentException(
"Binary string length must not be greater than "
+ MAX_PREFIX_LENGTH);
}
for (int i = 0; i < binaryString.length(); i++) {
char character = binaryString.charAt(i);
if (character != '0' && character != '1') {
throw new IllegalArgumentException(
"Binary string may only contain the characters "
+ "\'0\' or \'1\'");
}
}
// Pad the binary string out to be MAX_PREFIX_LENGTH bits long
StringBuilder paddedBinaryString = new StringBuilder(MAX_PREFIX_LENGTH);
paddedBinaryString.append(binaryString);
for (int i = binaryString.length(); i < MAX_PREFIX_LENGTH; i++) {
paddedBinaryString.append('0');
}
// BigInteger will parse the binary string to an integer using radix 2
BigInteger bigInteger =
new BigInteger(paddedBinaryString.toString(), BINARY_RADIX);
// Convert the integer to a byte array
ByteBuffer bb = ByteBuffer.allocate(ADDRESS_LENGTH_BYTES);
bb.putInt(bigInteger.intValue());
return new Prefix(bb.array(), binaryString.length());
}
}