golang unterscheidet IPv4 IPv6

Für ein Programm mit dem ich arbeite, habe ich, um zu überprüfen, ob eine IP-Adresse (die IP, die verbindet mich mit dem Internet) privat oder öffentlich ist. Für dass, ich brauche, um zu unterscheiden, ob eine IP-Adresse für IPv4-oder IPv6.

Wollte ich es überprüfen, indem Sie die Länge des IP -:

conn, err := net.Dial("udp", "8.9.10.11:2342")
if err != nil {
    fmt.Println("Error", err)
}

localaddr := conn.LocalAddr()

addr, _ := net.ResolveUDPAddr("udp", localaddr.String())

ip := addr.IP

fmt.Println(ip)
fmt.Println(len(ip))

Gut, meine IP ist 192.168.2.100, also IPv4, aber len(ip) sagt mir, dass die Länge ist 16, das wäre IPv6.
Was ist mein Fehler? Jede andere Methode existiert, um zu unterscheiden zwischen IPv4-und IPv6-das funktioniert immer?

InformationsquelleAutor der Frage user3479275 | 2014-03-30

  1. 30

    jimt s Antwort ist korrekt, aber ziemlich kompliziert. Ich würde einfach schauen ip.To4() != nil. Da die Dokumentation sagt, "wenn ip ist keine IPv4 Adresse, To4, wird nil zurückgegeben" sollte dieser Zustand zurück true wenn und nur wenn die Adresse eine IPv4-Adresse.

    InformationsquelleAutor der Antwort Evan

  2. 10

    Die Länge des IP ist fast immer 16, weil die interne Darstellung net.IP ist die gleiche für beide Fall. Von die Dokumentation:

    Beachten Sie, dass in dieser Dokumentation bezieht sich auf eine IP-Adresse als IPv4-Adresse oder eine IPv6-Adresse ist eine semantische Eigenschaft der Adresse, nicht nur die Länge des byte-slice: ein 16-byte-slice kann noch eine IPv4-Adresse.

    Trennung der beiden Typen hängt davon ab, wie die IP initialisiert wurde. Suche den code für net.IPv4()können Sie sehen, es ist initialisiert, um 16 bytes, für die die ersten 12 bytes sind der Wert der v4InV6Prefix.

    //IPv4 returns the IP address (in 16-byte form) of the
//IPv4 address a.b.c.d.
func IPv4(a, b, c, d byte) IP {
    p := make(IP, IPv6len)
    copy(p, v4InV6Prefix)
    p[12] = a
    p[13] = b
    p[14] = c
    p[15] = d
    return p
}

    Wo v4InV6Prefix ist definiert als:

    var v4InV6Prefix = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}

    Wenn Sie möchten, eine zuverlässige Differenzierung, schauen, wie die Quelle für net.IP.To4 Griffe:

    //To4 converts the IPv4 address ip to a 4-byte representation.
//If ip is not an IPv4 address, To4 returns nil.
func (ip IP) To4() IP {
    if len(ip) == IPv4len {
            return ip
    }
    if len(ip) == IPv6len &&
            isZeros(ip[0:10]) &&
            ip[10] == 0xff &&
            ip[11] == 0xff {
            return ip[12:16]
    }
    return nil
}

    isZeros nicht exportiert, so haben Sie zu kopieren, dass der code lokal. Dann können Sie einfach das gleiche tun wie oben zu bestimmen, ob Sie IPv4 oder IPv6.

    InformationsquelleAutor der Antwort jimt

  3. 2

    Ich benutzen würde .To4(), .16() ,aus dem net-Paket zu finden, wenn es sich um eine IPv4-oder IPv6-Adresse.
    überprüfen Sie die blog-post. überprüfen Sie den letzten Abschnitt des Blogs, zum Beispiel, könnte Ihnen helfen.

    InformationsquelleAutor der Antwort srini

  4. 2

    govalidator prüft das Vorhandensein von : im string.

    func IsIPv6(str string) bool {
  ip := net.ParseIP(str)
  return ip != nil && strings.Contains(str, ":")
}

    InformationsquelleAutor der Antwort Zamicol

  5. 2

    Den akzeptierte Antwort von Evan (ip.To4() != nil) löst die Frage. Allerdings gab es einige Kommentare und andere Antworten, die überprüfen, ob die Darstellung ist IPv4 oder IPv6, und Sie sind nicht immer genau:

    HINWEIS: EIN paar von Listen von gültigen IPv4-und IPv6-gültige Notationen bzw. Folgen. Jeder Eintrag repräsentiert eine variation über das erste basic. Die Variationen kombiniert werden können, wie gewünscht, aber aus Platzgründen keine variation-Kombination aufgeführt ist, ausgenommen zur Beseitigung von Mehrdeutigkeit.

    Gültige IPv4-Notationen:

    • "192.168.0.1": basic
    • "192.168.0.1:80": mit port info

    Gültige IPv6-Notationen:

    • "::FFFF:C0A8:1": basic
    • "::FFFF:C0A8:0001": führende Nullen
    • "0000:0000:0000:0000:0000:FFFF:C0A8:1": Doppel-Doppelpunkt erweitert
    • "::FFFF:C0A8:1%1": mit zone info
    • "::FFFF:192.168.0.1": IPv4-literal
    • "[::FFFF:C0A8:1]:80": mit port info
    • "[::FFFF:C0A8:1%1]:80": mit zone und die port-info

    All diesen Fällen (sowohl IPv4 und IPv6-Listen) würde als IPv4-Adressen, die von die net - Paket.
    Die IPv4-literal variation der IPv6-Liste als IPv4 durch govalidator.

    Der einfachste Weg, um zu überprüfen, ob es ist eine IPv4-oder IPv6-Adresse wäre die folgende:

    import strings

func IsIPv4(address string) bool {
    return strings.Count(address, ":") < 2
}

func IsIPv6(address string) bool {
    return strings.Count(address, ":") >= 2
}

    InformationsquelleAutor der Antwort Adirio

Schreibe einen Kommentar