| Methods Summary |
|---|
| public static java.lang.String | addressToString(int value)
return ((value >> 24) & 0xff) + "." + ((value >> 16) & 0xff) + "."
+ ((value >> 8) & 0xff) + "." + (value & 0xff);
|
| public static int | bytesToInt(byte[] bytes, int start)Takes the byte array and creates an integer out of four bytes starting at
start as the high-order byte. This method makes no checks on the validity
of the parameters.
// First mask the byte with 255, as when a negative
// signed byte converts to an integer, it has bits
// on in the first 3 bytes, we are only concerned
// about the right-most 8 bits.
// Then shift the rightmost byte to align with its
// position in the integer.
int value = ((bytes[start + 3] & 255))
| ((bytes[start + 2] & 255) << 8)
| ((bytes[start + 1] & 255) << 16)
| ((bytes[start] & 255) << 24);
return value;
|
| public static void | convertToBytes(java.lang.String hexWord, byte[] ipByteArray, int byteIndex)Converts a 4 character hex word into a 2 byte word equivalent
int hexWordLength = hexWord.length();
int hexWordIndex = 0;
ipByteArray[byteIndex] = 0;
ipByteArray[byteIndex + 1] = 0;
int charValue;
// high order 4 bits of first byte
if (hexWordLength > 3) {
charValue = getIntValue(hexWord.charAt(hexWordIndex++));
ipByteArray[byteIndex] = (byte) (ipByteArray[byteIndex] | (charValue << 4));
}
// low order 4 bits of the first byte
if (hexWordLength > 2) {
charValue = getIntValue(hexWord.charAt(hexWordIndex++));
ipByteArray[byteIndex] = (byte) (ipByteArray[byteIndex] | charValue);
}
// high order 4 bits of second byte
if (hexWordLength > 1) {
charValue = getIntValue(hexWord.charAt(hexWordIndex++));
ipByteArray[byteIndex + 1] = (byte) (ipByteArray[byteIndex + 1] | (charValue << 4));
}
// low order 4 bits of the first byte
charValue = getIntValue(hexWord.charAt(hexWordIndex));
ipByteArray[byteIndex + 1] = (byte) (ipByteArray[byteIndex + 1] | charValue & 15);
|
| public static byte[] | createByteArrayFromIPAddressString(java.lang.String ipAddressString)Creates an byte[] based on an ipAddressString. No error handling is
performed here.
if (isValidIPV4Address(ipAddressString)) {
StringTokenizer tokenizer = new StringTokenizer(ipAddressString, ".");
String token = "";
int tempInt = 0;
byte[] byteAddress = new byte[4];
for (int i = 0; i < 4; i++) {
token = tokenizer.nextToken();
tempInt = Integer.parseInt(token);
byteAddress[i] = (byte) tempInt;
}
return byteAddress;
}
if (ipAddressString.charAt(0) == '[") {
ipAddressString = ipAddressString.substring(1, ipAddressString.length() - 1);
}
StringTokenizer tokenizer = new StringTokenizer(ipAddressString, ":.", true);
ArrayList<String> hexStrings = new ArrayList<String>();
ArrayList<String> decStrings = new ArrayList<String>();
String token = "";
String prevToken = "";
// If a double colon exists, we need to insert 0s.
int doubleColonIndex = -1;
/*
* Go through the tokens, including the separators ':' and '.' When we
* hit a : or . the previous token will be added to either the hex list
* or decimal list. In the case where we hit a :: we will save the index
* of the hexStrings so we can add zeros in to fill out the string
*/
while (tokenizer.hasMoreTokens()) {
prevToken = token;
token = tokenizer.nextToken();
if (token.equals(":")) {
if (prevToken.equals(":")) {
doubleColonIndex = hexStrings.size();
} else if (!prevToken.equals("")) {
hexStrings.add(prevToken);
}
} else if (token.equals(".")) {
decStrings.add(prevToken);
}
}
if (prevToken.equals(":")) {
if (token.equals(":")) {
doubleColonIndex = hexStrings.size();
} else {
hexStrings.add(token);
}
} else if (prevToken.equals(".")) {
decStrings.add(token);
}
// figure out how many hexStrings we should have
// also check if it is a IPv4 address
int hexStringsLength = 8;
// If we have an IPv4 address tagged on at the end, subtract
// 4 bytes, or 2 hex words from the total
if (decStrings.size() > 0) {
hexStringsLength -= 2;
}
// if we hit a double Colon add the appropriate hex strings
if (doubleColonIndex != -1) {
int numberToInsert = hexStringsLength - hexStrings.size();
for (int i = 0; i < numberToInsert; i++) {
hexStrings.add(doubleColonIndex, "0");
}
}
byte ipByteArray[] = new byte[16];
// Finally convert these strings to bytes...
for (int i = 0; i < hexStrings.size(); i++) {
convertToBytes(hexStrings.get(i), ipByteArray, i * 2);
}
// Now if there are any decimal values, we know where they go...
for (int i = 0; i < decStrings.size(); i++) {
ipByteArray[i + 12] = (byte) (Integer.parseInt(decStrings.get(i)) & 255);
}
// now check to see if this guy is actually and IPv4 address
// an ipV4 address is ::FFFF:d.d.d.d
boolean ipV4 = true;
for (int i = 0; i < 10; i++) {
if (ipByteArray[i] != 0) {
ipV4 = false;
break;
}
}
if (ipByteArray[10] != -1 || ipByteArray[11] != -1) {
ipV4 = false;
}
if (ipV4) {
byte ipv4ByteArray[] = new byte[4];
for (int i = 0; i < 4; i++) {
ipv4ByteArray[i] = ipByteArray[i + 12];
}
return ipv4ByteArray;
}
return ipByteArray;
|
| public static java.lang.String | createIPAddrStringFromByteArray(byte[] ipByteArray)
// END android-changed
if (ipByteArray.length == 4) {
return addressToString(bytesToInt(ipByteArray, 0));
}
if (ipByteArray.length == 16) {
if (isIPv4MappedAddress(ipByteArray)) {
byte ipv4ByteArray[] = new byte[4];
for (int i = 0; i < 4; i++) {
ipv4ByteArray[i] = ipByteArray[i + 12];
}
return addressToString(bytesToInt(ipv4ByteArray, 0));
}
StringBuilder buffer = new StringBuilder();
// BEGIN android-changed
for (int i = 0; i < 8; i++) { // ipByteArray.length / 2
int num = (ipByteArray[2 * i] & 0xff) << 8;
num ^= ipByteArray[2 * i + 1] & 0xff;
// count the digits to display without leading 0
int count = 1, j = num;
while ((j >>>= 4) != 0) {
count++;
}
char[] buf = new char[count];
do {
int t = num & 0x0f;
buf[--count] = hexCharacters[t];
num >>>= 4;
} while (count > 0);
buffer.append(buf);
if ((i + 1) < 8) { // ipByteArray.length / 2
buffer.append(":");
}
}
// END android-changed
return buffer.toString();
}
return null;
|
| static int | getIntValue(char c)
switch (c) {
case '0":
return 0;
case '1":
return 1;
case '2":
return 2;
case '3":
return 3;
case '4":
return 4;
case '5":
return 5;
case '6":
return 6;
case '7":
return 7;
case '8":
return 8;
case '9":
return 9;
}
c = Character.toLowerCase(c);
switch (c) {
case 'a":
return 10;
case 'b":
return 11;
case 'c":
return 12;
case 'd":
return 13;
case 'e":
return 14;
case 'f":
return 15;
}
return 0;
|
| public static boolean | isIP6AddressInFullForm(java.lang.String ipAddress)
if (isValidIP6Address(ipAddress)) {
int doubleColonIndex = ipAddress.indexOf("::");
if (doubleColonIndex >= 0) {
// Simplified form which contains ::
return false;
}
return true;
}
return false;
|
| private static boolean | isIPv4MappedAddress(byte[] ipAddress)
// Check if the address matches ::FFFF:d.d.d.d
// The first 10 bytes are 0. The next to are -1 (FF).
// The last 4 bytes are varied.
for (int i = 0; i < 10; i++) {
if (ipAddress[i] != 0) {
return false;
}
}
if (ipAddress[10] != -1 || ipAddress[11] != -1) {
return false;
}
return true;
|
| static boolean | isValidHexChar(char c)
return (c >= '0" && c <= '9") || (c >= 'A" && c <= 'F")
|| (c >= 'a" && c <= 'f");
|
| public static boolean | isValidIP4Word(java.lang.String word)
char c;
if (word.length() < 1 || word.length() > 3) {
return false;
}
for (int i = 0; i < word.length(); i++) {
c = word.charAt(i);
if (!(c >= '0" && c <= '9")) {
return false;
}
}
if (Integer.parseInt(word) > 255) {
return false;
}
return true;
|
| public static boolean | isValidIP6Address(java.lang.String ipAddress)
int length = ipAddress.length();
boolean doubleColon = false;
int numberOfColons = 0;
int numberOfPeriods = 0;
int numberOfPercent = 0;
String word = "";
char c = 0;
char prevChar = 0;
int offset = 0; // offset for [] IP addresses
if (length < 2) {
return false;
}
for (int i = 0; i < length; i++) {
prevChar = c;
c = ipAddress.charAt(i);
switch (c) {
// case for an open bracket [x:x:x:...x]
case '[":
if (i != 0) {
return false; // must be first character
}
if (ipAddress.charAt(length - 1) != ']") {
return false; // must have a close ]
}
offset = 1;
if (length < 4) {
return false;
}
break;
// case for a closed bracket at end of IP [x:x:x:...x]
case ']":
if (i != length - 1) {
return false; // must be last character
}
if (ipAddress.charAt(0) != '[") {
return false; // must have a open [
}
break;
// case for the last 32-bits represented as IPv4 x:x:x:x:x:x:d.d.d.d
case '.":
numberOfPeriods++;
if (numberOfPeriods > 3) {
return false;
}
if (!isValidIP4Word(word)) {
return false;
}
if (numberOfColons != 6 && !doubleColon) {
return false;
}
// a special case ::1:2:3:4:5:d.d.d.d allows 7 colons with an
// IPv4 ending, otherwise 7 :'s is bad
if (numberOfColons == 7 && ipAddress.charAt(0 + offset) != ':"
&& ipAddress.charAt(1 + offset) != ':") {
return false;
}
word = "";
break;
case ':":
numberOfColons++;
if (numberOfColons > 7) {
return false;
}
if (numberOfPeriods > 0) {
return false;
}
if (prevChar == ':") {
if (doubleColon) {
return false;
}
doubleColon = true;
}
word = "";
break;
case '%":
if (numberOfColons == 0) {
return false;
}
numberOfPercent++;
// validate that the stuff after the % is valid
if ((i + 1) >= length) {
// in this case the percent is there but no number is
// available
return false;
}
try {
Integer.parseInt(ipAddress.substring(i + 1));
} catch (NumberFormatException e) {
// right now we just support an integer after the % so if
// this is not
// what is there then return
return false;
}
break;
default:
if (numberOfPercent == 0) {
if (word.length() > 3) {
return false;
}
if (!isValidHexChar(c)) {
return false;
}
}
word += c;
}
}
// Check if we have an IPv4 ending
if (numberOfPeriods > 0) {
if (numberOfPeriods != 3 || !isValidIP4Word(word)) {
return false;
}
} else {
// If we're at then end and we haven't had 7 colons then there is a
// problem unless we encountered a doubleColon
if (numberOfColons != 7 && !doubleColon) {
return false;
}
// If we have an empty word at the end, it means we ended in either
// a : or a .
// If we did not end in :: then this is invalid
if (numberOfPercent == 0) {
if (word == "" && ipAddress.charAt(length - 1 - offset) == ':"
&& ipAddress.charAt(length - 2 - offset) != ':") {
return false;
}
}
}
return true;
|
| public static boolean | isValidIPV4Address(java.lang.String value)Takes a string and parses it to see if it is a valid IPV4 address.
// BEGIN android-changed
// general test
if (!value.matches("\\p{Digit}+(\\.\\p{Digit}+)*")) {
return false;
}
String[] parts = value.split("\\.");
int length = parts.length;
if (length < 1 || length > 4) {
return false;
}
if (length == 1) {
// One part decimal numeric address
long longValue = Long.parseLong(parts[0]);
return longValue <= 0xFFFFFFFFL;
} else {
// Test each part for inclusion in the correct range
for (int i = 0; i < length; i++) {
// For two part addresses, the second part expresses
// a 24-bit quantity; for three part addresses, the third
// part expresses a 16-bit quantity.
int max = 0xff;
if ((length == 2) && (i == 1)) {
max = 0xffffff;
} else if ((length == 3) && (i == 2)) {
max = 0xffff;
}
if (Integer.parseInt(parts[i]) > max) {
return false;
}
}
return true;
}
// END android-changed
|
