La Conversion de l'IPv6 à long et long terme pour IPv6

Comment dois-je effectuer la conversion depuis l'IPv6 à long et vice versa?

Pour l'instant j'ai:

    public static long IPToLong(String addr) {
            String[] addrArray = addr.split("\\.");
            long num = 0;
            for (int i = 0; i < addrArray.length; i++) {
                    int power = 3 - i;

                    num += ((Integer.parseInt(addrArray[i], 16) % 256 * Math.pow(256, power)));
            }
            return num;
    }

    public static String longToIP(long ip) {
            return ((ip >> 24) & 0xFF) + "."
                    + ((ip >> 16) & 0xFF) + "."
                    + ((ip >> 8) & 0xFF) + "."
                    + (ip & 0xFF);

    }

Est-ce la bonne solution ou j'ai raté quelque chose?

(Il serait parfait si la solution a fonctionné pour ipv4 et ipv6)

OriginalL'auteur Testeross | 2013-07-26

9

Une adresse IPv6 est un nombre de 128 bits comme décrit ici. Une longue Java est représenté sur 64 bits, si vous avez besoin d'une autre structure, comme un BigDecimal ou deux longs (un récipient avec un tableau de deux longs ou tout simplement un tableau de deux longs) pour stocker une adresse IPv6.

Ci-dessous est un exemple (juste pour vous donner une idée):
```
public class Asd {
public static long[] IPToLong(String addr) {
String[] addrArray = addr.split(":");//a IPv6 adress is of form 2607:f0d0:1002:0051:0000:0000:0000:0004
long[] num = new long[addrArray.length];
for (int i=0; i<addrArray.length; i++) {
num[i] = Long.parseLong(addrArray[i], 16);
}
long long1 = num[0];
for (int i=1;i<4;i++) {
long1 = (long1<<16) + num[i];
}
long long2 = num[4];
for (int i=5;i<8;i++) {
long2 = (long2<<16) + num[i];
}
long[] longs = {long2, long1};
return longs;
}
public static String longToIP(long[] ip) {
String ipString = "";
for (long crtLong : ip) {//for every long: it should be two of them
for (int i=0; i<4; i++) {//we display in total 4 parts for every long
ipString = Long.toHexString(crtLong & 0xFFFF) + ":" + ipString;
crtLong = crtLong >> 16;
}
}
return ipString;
}
static public void main(String[] args) {
String ipString = "2607:f0d0:1002:0051:0000:0000:0000:0004";
long[] asd = IPToLong(ipString);
System.out.println(longToIP(asd));
}
```
}

Ok, je vais le faire. Ce sujet de la conversion? Est-il fait?
Il est assez facile à tester: exécuter longToIP(IPToLong("122.122.122.124")) et vous obtiendrez "34.34.34.36" au lieu de l'original "122.122.122.124", ce qui signifie quelque chose n'est pas correct.
Vous avez raison. Avez-vous une idée de ce qui est mal?
Le problème est le suivant: vous avez essayé d'adapter le code pour l'IPv4 à l'IPv6, ce qui est incorrect, parce qu'en IPv4, les chiffres sont codés en base 10 (le numéro 124 de l'adresse IP "122.122.122.124" est en base 10), mais en IPv6, toutes les pièces sont codées en hexadécimal. Cela signifie, que vous aurez à décider en quelque sorte la version de l'adresse IP, puis à prendre des décisions, afin d'avoir une méthode pour les deux versions.
Ajout d'un morceau de code de travail, mais ne l'esprit qu'il manque quelques vérifications (comme la Chaîne non valide), donc c'est ok pour vos devoirs, mais n'est pas suffisamment testés pour la production.

OriginalL'auteur Andrei I
13

Vous pouvez également utiliser java.net.InetAddress

Il fonctionne à la fois en ipv4 et ipv6 (tous les formats)
```
public static BigInteger ipToBigInteger(String addr) {
InetAddress a = InetAddress.getByName(addr)
byte[] bytes = a.getAddress()
return new BigInteger(1, bytes)
}
```
Cela vous donnera des nombres négatifs pour la moitié supérieure de la plage d'adresse IP. Si vous voulez qu'il soit non signé, vous devez passer dans le signum pour rester positif évalué (c'est à dire de nouveaux BigInteger(1, octets)).
Merci pour le commentaire. Réponse de mise à jour.

OriginalL'auteur Guigoz

Une adresse IPv6 ne peuvent pas être stockées dans de long. Vous pouvez utiliser BigInteger au lieu de long.

public static BigInteger ipv6ToNumber(String addr) {
int startIndex=addr.indexOf("::");
if(startIndex!=-1){
String firstStr=addr.substring(0,startIndex);
String secondStr=addr.substring(startIndex+2, addr.length());
BigInteger first=ipv6ToNumber(firstStr);
int x=countChar(addr, ':');
first=first.shiftLeft(16*(7-x)).add(ipv6ToNumber(secondStr));
return first;
}
String[] strArr = addr.split(":");
BigInteger retValue = BigInteger.valueOf(0);
for (int i=0;i<strArr.length;i++) {
BigInteger bi=new BigInteger(strArr[i], 16);
retValue = retValue.shiftLeft(16).add(bi);
}
return retValue;
}
public static String numberToIPv6(BigInteger ipNumber) {
String ipString ="";
BigInteger a=new BigInteger("FFFF", 16);
for (int i=0; i<8; i++) {
ipString=ipNumber.and(a).toString(16)+":"+ipString;
ipNumber = ipNumber.shiftRight(16);
}
return ipString.substring(0, ipString.length()-1);
}
public static int countChar(String str, char reg){
char[] ch=str.toCharArray();
int count=0;
for(int i=0; i<ch.length; ++i){
if(ch[i]==reg){
if(ch[i+1]==reg){
++i;
continue;
}
++count;
}
}
return count;
}

OriginalL'auteur Vinod

Vinod la réponse est juste. Mais il y a encore certaines choses qui peuvent être améliorées.(Désolé je ne peux pas ajouter un commentaire ci-dessous Vinod de répondre parce que je suis nouveau ici.)

Tout d'abord, dans la méthode 'countChar', 'continuer' doit être remplacé par "pause".

Et deuxièmement, des conditions aux limites doivent être considérés.

public static BigInteger ipv6ToNumber(String addr) {
int startIndex = addr.indexOf("::");
if (startIndex != -1) {
String firstStr = addr.substring(0, startIndex);
String secondStr = addr.substring(startIndex + 2, addr.length());
BigInteger first = new BigInteger("0");
BigInteger second = new BigInteger("0");
if (!firstStr.equals("")) {
int x = countChar(addr, ':');
first = ipv6ToNumber(firstStr).shiftLeft(16 * (7 - x));
}
if (!secondStr.equals("")) {
second = ipv6ToNumber(secondStr);
}
first = first.add(second);
return first;
}
String[] strArr = addr.split(":");
BigInteger retValue = BigInteger.valueOf(0);
for (int i = 0; i < strArr.length; i++) {
BigInteger bi = new BigInteger(strArr[i], 16);
retValue = retValue.shiftLeft(16).add(bi);
}
return retValue;
}
public static int countChar(String str, char reg){
char[] ch=str.toCharArray();
int count=0;
for(int i=0; i<ch.length; ++i){
if(ch[i]==reg){
if(ch[i+1]==reg){
++i;
break;
}
++count;
}
}
return count;
}

OriginalL'auteur gaofc

Vous devez vous connecter pour publier un commentaire.