/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.luni.util;
import java.util.ArrayList;
import java.util.StringTokenizer;
/**
* Utility functions for IPV6 operations.
*/
public class Inet6Util {
public static boolean isIP6AddressInFullForm(String ipAddress) {
if (isValidIP6Address(ipAddress)) {
int doubleColonIndex = ipAddress.indexOf("::");
if (doubleColonIndex >= 0) {
// Simplified form which contains ::
return false;
}
return true;
}
return false;
}
public static boolean isValidIP6Address(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 isValidIP4Word(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;
}
static boolean isValidHexChar(char c) {
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
|| (c >= 'a' && c <= 'f');
}
/**
* Takes a string and parses it to see if it is a valid IPV4 address.
*
* @return true, if the string represents an IPV4 address in dotted
* notation, false otherwise
*/
public static boolean isValidIPV4Address(String value) {
// 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
}
}