/*
* This file is part of JSTUN.
*
* Copyright (c) 2005 Thomas King - All rights
* reserved.
*
* This software is licensed under either the GNU Public License (GPL),
* or the Apache 2.0 license. Copies of both license agreements are
* included in this distribution.
*/
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.StringTokenizer;
public class Address {
int firstOctet;
int secondOctet;
int thirdOctet;
int fourthOctet;
public Address(int firstOctet, int secondOctet, int thirdOctet,
int fourthOctet) throws UtilityException {
if ((firstOctet < 0) || (firstOctet > 255) || (secondOctet < 0)
|| (secondOctet > 255) || (thirdOctet < 0)
|| (thirdOctet > 255) || (fourthOctet < 0)
|| (fourthOctet > 255)) {
throw new UtilityException("Address is malformed.");
}
this.firstOctet = firstOctet;
this.secondOctet = secondOctet;
this.thirdOctet = thirdOctet;
this.fourthOctet = fourthOctet;
}
public Address(String address) throws UtilityException {
StringTokenizer st = new StringTokenizer(address, ".");
if (st.countTokens() != 4) {
throw new UtilityException(
"4 octets in address string are required.");
}
int i = 0;
while (st.hasMoreTokens()) {
int temp = Integer.parseInt(st.nextToken());
if ((temp < 0) || (temp > 255)) {
throw new UtilityException("Address is in incorrect format.");
}
switch (i) {
case 0:
firstOctet = temp;
++i;
break;
case 1:
secondOctet = temp;
++i;
break;
case 2:
thirdOctet = temp;
++i;
break;
case 3:
fourthOctet = temp;
++i;
break;
}
}
}
public Address(byte[] address) throws UtilityException {
if (address.length < 4) {
throw new UtilityException("4 bytes are required.");
}
firstOctet = Utility.oneByteToInteger(address[0]);
secondOctet = Utility.oneByteToInteger(address[1]);
thirdOctet = Utility.oneByteToInteger(address[2]);
fourthOctet = Utility.oneByteToInteger(address[3]);
}
public String toString() {
return firstOctet + "." + secondOctet + "." + thirdOctet + "."
+ fourthOctet;
}
public byte[] getBytes() throws UtilityException {
byte[] result = new byte[4];
result[0] = Utility.integerToOneByte(firstOctet);
result[1] = Utility.integerToOneByte(secondOctet);
result[2] = Utility.integerToOneByte(thirdOctet);
result[3] = Utility.integerToOneByte(fourthOctet);
return result;
}
public InetAddress getInetAddress() throws UtilityException,
UnknownHostException {
byte[] address = new byte[4];
address[0] = Utility.integerToOneByte(firstOctet);
address[1] = Utility.integerToOneByte(secondOctet);
address[2] = Utility.integerToOneByte(thirdOctet);
address[3] = Utility.integerToOneByte(fourthOctet);
return InetAddress.getByAddress(address);
}
public boolean equals(Object obj) {
if (obj == null)
return false;
try {
byte[] data1 = this.getBytes();
byte[] data2 = ((Address) obj).getBytes();
if ((data1[0] == data2[0]) && (data1[1] == data2[1])
&& (data1[2] == data2[2]) && (data1[3] == data2[3]))
return true;
return false;
} catch (UtilityException ue) {
return false;
}
}
public int hashCode() {
return (firstOctet << 24) + (secondOctet << 16) + (thirdOctet << 8)
+ fourthOctet;
}
}
class UtilityException extends Exception {
private static final long serialVersionUID = 3545800974716581680L;
UtilityException(String mesg) {
super(mesg);
}
}
class Utility {
public static final byte integerToOneByte(int value) throws UtilityException {
if ((value > Math.pow(2,15)) || (value < 0)) {
throw new UtilityException("Integer value " + value + " is larger than 2^15");
}
return (byte)(value & 0xFF);
}
public static final byte[] integerToTwoBytes(int value) throws UtilityException {
byte[] result = new byte[2];
if ((value > Math.pow(2,31)) || (value < 0)) {
throw new UtilityException("Integer value " + value + " is larger than 2^31");
}
result[0] = (byte)((value >>> 8) & 0xFF);
result[1] = (byte)(value & 0xFF);
return result;
}
public static final byte[] integerToFourBytes(int value) throws UtilityException {
byte[] result = new byte[4];
if ((value > Math.pow(2,63)) || (value < 0)) {
throw new UtilityException("Integer value " + value + " is larger than 2^63");
}
result[0] = (byte)((value >>> 24) & 0xFF);
result[1] = (byte)((value >>> 16) & 0xFF);
result[2] = (byte)((value >>> 8) & 0xFF);
result[3] = (byte)(value & 0xFF);
return result;
}
public static final int oneByteToInteger(byte value) throws UtilityException {
return (int)value & 0xFF;
}
public static final int twoBytesToInteger(byte[] value) throws UtilityException {
if (value.length < 2) {
throw new UtilityException("Byte array too short!");
}
int temp0 = value[0] & 0xFF;
int temp1 = value[1] & 0xFF;
return ((temp0 << 8) + temp1);
}
public static final long fourBytesToLong(byte[] value) throws UtilityException {
if (value.length < 4) {
throw new UtilityException("Byte array too short!");
}
int temp0 = value[0] & 0xFF;
int temp1 = value[1] & 0xFF;
int temp2 = value[2] & 0xFF;
int temp3 = value[3] & 0xFF;
return (((long)temp0 << 24) + (temp1 << 16) + (temp2 << 8) + temp3);
}
}