golang distinguer IPv4 IPv6

Pour un programme sur lequel je travaille, je dois vérifier si une adresse IP (l'adresse IP qui me relie à l'Internet) est public ou privé. Pour cela, j'ai besoin de distinguer si l'adresse IP IPv4 ou IPv6.

Je voulais le vérifier par la longueur de la propriété intellectuelle: 

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))

Bien, mon IP est 192.168.2.100, donc IPv4, mais len(ip) me dit que la longueur est de 16 ans qui serait IPv6.
Quelle est mon erreur? Toute autre méthode existe pas de distinguer entre l'IPv4 et l'IPv6 qui fonctionne toujours?

InformationsquelleAutor user3479275 | 2014-03-30
  1. 32

    jimt la réponse est correcte, mais assez compliqué. Je voudrais simplement vérifier ip.To4() != nil. Étant donné que la documentation dit "si l'ip n'est pas une adresse IPv4, To4 retourne nil" cette condition doit retourner true si et seulement si l'adresse est une adresse IPv4.

    • Apparemment ce n'est pas toujours exacte: github.com/asaskevich/govalidator/pull/100
    • L'ajout de @tmm1 's commentaire, la solution proposée dans ce lien n'est pas toujours fiables. ::FFFF:127.0.0.1 est une IPv6 valide représentation et retourne True pour IsIPv4() quand il doit retourner False.
    • La question initiale n'était pas de savoir si le représentation a été en v4 ou v6 forme, c'était de savoir si le adresse est valide v4 ou v6 adresse. ::FFFF: est le v4InV6Prefix, donc ::FFFF:127.0.0.1 est, en fait, d'un visa d'adresse IPv4 pour toutes fins utiles.
    • Je suis d'accord que votre réponse couvre l'OP question, j'étais en ajoutant quelque chose pour le commentaire précédent. J'ai ajouté un réponse avec l'information à propos de la représentation. Fera de ce point clair dans la réponse ainsi.
    InformationsquelleAutor Evan
  2. 10

    La longueur de la propriété intellectuelle est presque toujours 16, parce que la représentation interne de net.IP est le même pour les deux cas. De la documentation:

    Noter que dans cette documentation, en se référant à une adresse IP est une adresse IPv4 ou adresse IPv6 est une propriété sémantique de l'adresse, et pas seulement de la longueur de l'octet tranche: 16 octets tranche peut encore être une adresse IPv4.

    Séparant les deux types dépend de la façon dont la propriété intellectuelle a été initialisé. En regardant le code pour net.IPv4(), vous pouvez voir qu'il est initialisé à 16 octets, pour lesquels les 12 premiers octets sont mis à la valeur de 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
}

    Où v4InV6Prefix est défini comme:

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

    Si vous voulez une distinction fiable, regardez comment la source pour net.IP.To4 gère:

    //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 n'est pas exporté, de sorte que vous aurez à copier ce code en local. Ensuite, vous pouvez simplement faire la même chose que ci-dessus pour déterminer si vous avez IPv4 ou IPv6.

    InformationsquelleAutor jimt
  3. 3

    govalidator vérifie la présence de : dans la chaîne.

    func IsIPv6(str string) bool {
  ip := net.ParseIP(str)
  return ip != nil && strings.Contains(str, ":")
}
    • govalidator s'attend à ce que les hôtes, si il y a un port a ajouté la méthode de saut de donner de faux positifs. Le IsIPv4(str string) bool méthode aussi des pauses pour "::FFFF:192.168.0.1" donner de faux positifs.
    InformationsquelleAutor Zamicol
  4. 3

    La accepté de répondre à par Evan (ip.To4() != nil) résout la question. Cependant, il ya eu certains commentaires et d'autres réponses que de vérifier si la représentation est IPv4 ou IPv6 et ils ne sont pas toujours précises:

    NOTE: UN couple de listes de valable IPv4 et IPv6 valide notations respectivement à suivre. Chaque entrée correspond à une variation au cours de la première base. Les variations peuvent être combinés, comme souhaité, mais pour des raisons d'espace pas de variation de la combinaison est à l'exception de l'élimination de l'ambiguïté.

    IPv4 valide les notations:

    • "192.168.0.1": base
    • "192.168.0.1:80": avec port info

    IPv6 valide les notations:

    • "::FFFF:C0A8:1": base
    • "::FFFF:C0A8:0001": le zéro de
    • "0000:0000:0000:0000:0000:FFFF:C0A8:1": deux points élargi
    • "::FFFF:C0A8:1%1": avec la zone info
    • "::FFFF:192.168.0.1": IPv4 littérale
    • "[::FFFF:C0A8:1]:80": avec port info
    • "[::FFFF:C0A8:1%1]:80": avec la zone et le port info

    Tous ces cas (à la fois IPv4 et IPv6 listes) seraient considérés comme des adresses IPv4 en le net le paquet.
    Le littéral IPv4 variation de l'IPv6 liste serait considérée être IPv4 par govalidator.

    La meilleure façon de vérifier si c'est une adresse IPv4 ou IPv6 serait le suivant:

    import strings

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

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

    Que j'allais utiliser .4(), .16() ,sur le net, pour trouver si c'est une adresse IPv4 ou IPv6.
    de vérifier la post de blog. vérifiez le dernier article du blog par exemple qui pourrait vous aider.

    InformationsquelleAutor srini