Prüfen, ob String eine gültige IPv6-Adresse ist

[CodeX]

Gibt es eine fertige Funktion, die prüfen kann, ob ein String eine gültige IPv6 Adresse ist?

Also für eine Verwendung wie:
if IsIPv6('2001:db8:85a3:8d3:1319:8a2e:370:7344') then ... Habe leider nur Prüfungen für IPv4-Adressen gefunden...

[jaenicke]

Möchtest du prüfen, ob der String prinzipiell eine gültige Adresse enthält oder ob die IP existiert?

Für die Existenz sollte getnameinfo helfen, diese ist ab Windows XP verfügbar:
http://msdn.microsoft.com/en-us/library/ms738532.aspx
Ab Vista kannst du auch einen solchen String in die Binärdarstellung umwandeln versuchen mit RtlIpv6StringToAddress:
http://msdn.microsoft.com/en-us/library/aa814462.aspx

Je nachdem ob nur Vista und Windows 7 oder auch XP unterstützt werden sollen, musst du schauen was du benutzt. Für XP gibt es wohl keine direkte Umwandlungsfunktion.

Grundsätzlich ist das zwar nicht ganz so einfach wie bei IPv4, aber so schwer ist die manuelle Prüfung auch nicht, dann wärst du nicht vom benutzten System abhängig.

[Luckie]

Man müsste doch nur prüfen, ob die Teile der IP-Adresse im gültigen Wertebereich sind. Bei IPv4 darf zum Beispiel in der Dezimaldarstellung kein Oktett größer als 255 sein. Ähnliches sollte für IPv6 auch gelten.

[jaenicke]

Die Überprüfung an sich ist nicht so schwer, das habe ich ja schon geschrieben.

Aber es gibt z.B. für ein und die selbe Adresse mehrere Schreibweisen. Dies wäre alles äquivalent...

Code:

ff00:0:ff::ff
ff00:0000:ff::ff
ff00:0:ff:0:0:0:0:ff
ff00:0000:ff:0000:0000:0000:0000:ff00

Und diese Adressen gibt es nicht...

Code:

ff00::ff:0:0::ff
ff00::ff::ff
ff00:0:ff:0:0:0:0:0:ff

Als Internetadresse gibts die IP dann noch in eckigen Klammern und ggf. mit Port dahinter.

Und ich weiß nicht, ob es da noch mehr gibt, was ich selbst bisher noch nicht weiß. Ich habe hier das lokale Netzwerk auf IPv6 umgestellt (zum Ausprobieren), das war nicht so lustig teilweise.

[CodeX]

Zitat von jaenicke:

Möchtest du prüfen, ob der String prinzipiell eine gültige Adresse enthält oder ob die IP existiert?

Ich möchte "nur" prüfen, ob es von der Form her eine mögliche IPv6 Adresse ist, unabhängig davon, ob diese im Netzwerk existiert.

Zitat von jaenicke:

Je nachdem ob nur Vista und Windows 7 oder auch XP unterstützt werden sollen, musst du schauen was du benutzt.

Die Funktion darf nicht auf neuere OS beschränkt sein. Deshalb kommen wohl die windowseigenen Funktionen nicht in Frage.

Zitat von jaenicke:

Grundsätzlich ist das zwar nicht ganz so einfach wie bei IPv4, aber so schwer ist die manuelle Prüfung auch nicht, dann wärst du nicht vom benutzten System abhängig.

Ja, da bin ich aber gut einen Tag damit beschäftigt, bis wirklich alle möglichen Formen korrekt erkannt werden (sofern ich nicht doch etwas übersehen habe...). Die unterscshiedlichen Darstellungsformen und ::-Verkürzungsmöglichkeit machen es da nicht gerade einfacher. Deshalb auch meine Frage, ob es sowas schon fertig gibt.

[Meflin]

Zitat von CodeX:

Ja, da bin ich aber gut einen Tag damit beschäftigt, bis wirklich alle möglichen Formen korrekt erkannt werden (sofern ich nicht doch etwas übersehen habe...). Die unterscshiedlichen Darstellungsformen und ::-Verkürzungsmöglichkeit machen es da nicht gerade einfacher. Deshalb auch meine Frage, ob es sowas schon fertig gibt.

Hier z.B.:
http://blogs.msdn.com/mpoulson/archi...10/350037.aspx
http://vernon.mauery.com/content/pro...nux/ipv6_regex

Aber wie fast immer bei Regular Expressions gilt: Optimal ists vermutlich nicht

[jaenicke]

Ok, als ich das mit den Regechsen eben gelesen habe, habe ich mir mal überlegt wie das einfacher geht. Dabei ist mir ein endlicher Automat eingefallen.

Und dann habe ich das einmal schnell umgesetzt. Ich weiß im Moment nicht ob :: am Anfang oder Ende erlaubt sind, bin aber davon ausgegangen, dass beides möglich ist. Die neue Schreibweise für localhost ist ja ::1, insofern kommt sowas ja vor.
Auch wenn Nullblocks wohl ansonsten kaum am Anfang vorkommen werden, sind es wohl gültige IPs, deshalb akzeptiere ich diese normal.

Delphi-Quellcode:

// Autor: Sebastian Jänicke (jaenicke @ delphipraxis.net)
// [url]http://www.delphipraxis.net/post1011159.html#1011159[/url]
function SJCheckIPv6(Value: String): Boolean;
type
  CheckIPState = (cisNone, cisDelim, cisDelimStart, cisDoubleDelim,
    cisHex1, cisHex2, cisHex3, cisHex4);
var
  DoubleDelim: Boolean;
  i, CurBlock: Integer;
  CurState: CheckIPState;
begin
  Result := False;
  DoubleDelim := False;
  CurState := cisNone;
  CurBlock := 0;
  for i := 1 to Length(Value) do
    case Value[i] of
      'a'..'f', '0'..'9':
        case CurState of
          cisNone, cisDelim:
            begin
              CurState := cisHex1;
              Inc(CurBlock);
              if CurBlock > 8 then
                Exit; // :: steht für mind. 2 Blöcke, mehr als 8 geht nicht
            end;
          cisDelimStart:
            Exit; // ein einzelnes : am Anfang geht nicht
          cisDoubleDelim:
            begin
              CurState := cisHex1;
              Inc(CurBlock, 3);
              if CurBlock > 8 then
                Exit; // :: steht für mind. 2 Blöcke, mehr als 8 geht nicht
              DoubleDelim := True;
            end;
          cisHex1:
            CurState := cisHex2;
          cisHex2:
            CurState := cisHex3;
          cisHex3:
            CurState := cisHex4;
          cisHex4:
            Exit; // Mehr als 4 hexadezimale Zeichen hintereinander geht nicht
        end;
      ':':
        case CurState of
          cisNone:
            CurState := cisDelimStart;
          cisDelim:
            if DoubleDelim or (CurBlock > 6) then
              Exit // zweimal :: geht nicht,
                   // außerdem steht :: für mind. 2 Blöcke, mehr als 8 geht nicht
            else
              CurState := cisDoubleDelim;
          cisDelimStart:
            CurState := cisDoubleDelim;
          cisDoubleDelim:
            Exit; // drittes : hintereinander ist nicht erlaubt
          cisHex1, cisHex2, cisHex3, cisHex4:
            CurState := cisDelim;
        end;
    else
      Exit; // ungültiges Zeichen
    end;
  Result := CurState <> cisDelim;
end;

// EDIT:
Ein paar Kommentare eingestreut.

// EDIT2:
Eine eingebettete IPv4 Adresse kannte ich bis eben gar nicht, das ist nicht drin.
Allerdings sollte das auf diese Art auch ggf. einfach zu ergänzen sein.

[CodeX]

Sieht gut aus.

Allerdings bin ich mir nicht so sicher, ob da wirklich alle Regeln miteinbezogen sind. Die Funktion liefert auch für leere und falsch verkürzte Strings true. ('' oder '0000:fff')

Ich hatte in der Zwischenzeit auch angefangen, eine eigene Funktion zu schreiben. Die ist definitiv nicht so kurz und schnell wie Deine, weil ich quasi für jede Regel auf eine eigene Prüfung zurückgreife, aber letztlich hängt es bei mir gerade auch an der vollständigen Regeldefinition. Damit habe ich u.A. das gleiche Problem, was ich gerade bei dir angemerkt habe.

Delphi-Quellcode:

  if //nicht länger als 39 Stellen 8*4+7
     (length(myIPv6) <= 39) and

     // max. ein Mal ::
     (CountPos('::', myIPv6) <= 1) and

     // nur 0-F und :
     (ValidCharsInString(myIPv6, ['0'..'9', 'A'..'F', 'a'..'f', ':'])) and

     // zwischen : und : max. 4 Stellen
     (MaxSubStringLength(myIPv6, ':') <=4)
then

Der Übersicht halber erspare ich mir hier den Inhalt der einzelnen Funktionen (bei Interesse kann ich sie natürlich auch noch posten).

Da ich den String nicht wie in Deiner SJCheckIPv6 in einem Durchgang Zeichen für Zeichen überprüfe, könnte ich weitere Prüfungen im Ganzen anhängen. Dafür fehlt es mir momentan aber an der Regel-Definition:
- Kürzest-mögliche Adresse (von localhost abgesehen)?
- Eventuell nur bestimmter Anfang der Adresse gültig (je nach Einer-Bitfolge) wie 2000, fc00, fe80, ff00?
- Sofern kein :: vorkommt, müssten es wohl 8 Blöcke bzw. 7 : sein
- ...

Ich befürchte einfach, dass das alles keine 100%ige Prüfung darstellt. Etwas besseres fällt mir aber auch nicht ein...

[jaenicke]

Ok, die Result Zuweisung am Ende muss dann so aussehen, das berücksichtigt beide Fälle:  Result := (CurState <> cisDelim) and ((CurBlock = 8) or DoubleDelim);

Zitat von CodeX:

Ich befürchte einfach, dass das alles keine 100%ige Prüfung darstellt. Etwas besseres fällt mir aber auch nicht ein...

Da du dich nicht auf bestimmte Betriebssysteme beschränken willst, wird es wohl nicht anders gehen.

[CodeX]

Zitat von jaenicke:

Ok, die Result Zuweisung am Ende muss dann so aussehen, das berücksichtigt beide Fälle:  Result := (CurState <> cisDelim) and ((CurBlock = 8) or DoubleDelim);

Und wie siehts mit '2001:db8:85a3:8d3:1319::370:7344' aus? (ein Block mit :: verkürzt)