IPv6-Validierung

Sehen, ob das funktioniert:

try {
    if (subjectString.matches(
        "(?ix)\\A(?:                                                  # Anchor address\n" +
        " (?:  # Mixed\n" +
        "  (?:[A-F0-9]{1,4}:){6}                                # Non-compressed\n" +
        " |(?=(?:[A-F0-9]{0,4}:){2,6}                           # Compressed with 2 to 6 colons\n" +
        "     (?:[0-9]{1,3}\\.){3}[0-9]{1,3}                     #    and 4 bytes\n" +
        "     \\z)                                               #    and anchored\n" +
        "  (([0-9A-F]{1,4}:){1,5}|:)((:[0-9A-F]{1,4}){1,5}:|:)  #    and at most 1 double colon\n" +
        " |::(?:[A-F0-9]{1,4}:){5}                              # Compressed with 7 colons and 5 numbers\n" +
        " )\n" +
        " (?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\\.){3}  # 255.255.255.\n" +
        " (?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])           # 255\n" +
        "|     # Standard\n" +
        " (?:[A-F0-9]{1,4}:){7}[A-F0-9]{1,4}                    # Standard\n" +
        "|     # Compressed\n" +
        " (?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}               # Compressed with at most 7 colons\n" +
        "    \\z)                                                #    and anchored\n" +
        " (([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)    #    and at most 1 double colon\n" +
        "|(?:[A-F0-9]{1,4}:){7}:|:(:[A-F0-9]{1,4}){7}           # Compressed with 8 colons\n" +
        ")/[A-F0-9]{0,4}\\z                                                    # Anchor address")) 
        {
        //String matched entirely
    } else {
        //Match attempt failed
    } 
} catch (PatternSyntaxException ex) {
    //Syntax error in the regular expression
}

Kaufte ich ein sehr hilfreiches Programm namens RegexMagic vor knapp einem Jahr für einige komplizierte reguläre Ausdrücke, die ich über die Verwendung der geplanten.

Dieser war wohl zu Java, so sollte es kompilieren, ich nehme an, das /60 kann zwischen den Bereichen von 0000 und FFFF die Sie ändern können, dass der Letzte Teil.

/[A-F0-9]{0,4} ist, was ich Hinzugefügt, um den regulären Ausdruck für dein Beispiel.

Streng genommen, einen Abschnitt 2.3 beschreibt nicht eine Adress-Darstellung, sondern eine Darstellung der Adresse Präfix (auch der "full-length" - Präfix ist nicht das gleiche wie eine Adresse).

Einer IPv6-Adresse Präfix ist
vertreten durch die notation:
ipv6-Adresse/Präfix-Länge
wo
ipv6-Adresse eine IPv6-Adresse in der Schreibweise aufgeführt
in Abschnitt 2.2.

Dass heißt, Sie können bedenkenlos ignorieren Sie dieses format, wenn Sie brauchen, um zu überprüfen Adressen.

Hatte ich versucht unten regex in java und es funktionierte für IPV4-und IPV6 -

public class Utilities {
private static Pattern VALID_IPV4_PATTERN = null;
private static Pattern VALID_IPV6_PATTERN = null;
private static final String ipv4Pattern = "(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])";
private static final String ipv6Pattern = "([0-9a-f]{1,4}:){7}([0-9a-f]){1,4}";

static {
try {
  VALID_IPV4_PATTERN = Pattern.compile(ipv4Pattern, Pattern.CASE_INSENSITIVE);
  VALID_IPV6_PATTERN = Pattern.compile(ipv6Pattern, Pattern.CASE_INSENSITIVE);
   } catch (PatternSyntaxException e) {
  //logger.severe("Unable to compile pattern", e);
 }
}

 /**
 * Determine if the given string is a valid IPv4 or IPv6 address.  This method
 * uses pattern matching to see if the given string could be a valid IP address.
 *
 * @param ipAddress A string that is to be examined to verify whether or not
 * it could be a valid IP address.
 * @return <code>true</code> if the string is a value that is a valid IP address,
 *  <code>false</code> otherwise.
 */
 public static boolean isIpAddress(String ipAddress) {

Matcher m1 = Utilities.VALID_IPV4_PATTERN.matcher(ipAddress);
if (m1.matches()) {
  return true;
}
Matcher m2 = Utilities.VALID_IPV6_PATTERN.matcher(ipAddress);
return m2.matches();
  }


}