# IP Hochzaehlen



## chrism120 (21. Aug 2019)

Hallo ich brauche Hifle. ich versuche alle Adresse von P1 zu P2 aufzulisten. das ist meine Stück kode. Diese funktioniert nicht wie erwartet. bitte Hilfe!!!!!!


```
int[] ip1 = new int[4];
        int[] ip2 = new int[4];
        String[] p1 = "172.168.447.45".split("\\.");
        String[] P2 = "235.235.45.45".split("\\.");
        for (int i = 0; i < 4; i++) {
            ip1[i] = Integer.parseInt(p1[i]);
            for (int j=0; i<4; j++){
                ip2[j]=Integer.parseInt(P2[j]);
                for (int k=ip1[i];k<ip2[j];k++){
                    System.out.print("Die Adresse ist " + k);
                }
            }
        }
    }
```


----------



## chrism120 (21. Aug 2019)

diese zählt nur das erste Octet also 172,173...


----------



## Xyz1 (21. Aug 2019)

```
private static LinkedList<String> between(String ipv41, String ipv42) {
	int[] a = new int[4];
	int[] b = new int[4];
	String[] s1 = ipv41.split("\\.");
	String[] s2 = ipv42.split("\\.");
	for (int i = 0; i < 4; i++) {
		a[i] = Integer.parseInt(s1[i]);
		b[i] = Integer.parseInt(s2[i]);
	}
	LinkedList<String> list = new LinkedList<>();
	while (!Arrays.equals(a, b)) {
		list.add(a[0] + "." + a[1] + "." + a[2] + "." + a[3]);
		for (int i = 3; i >= 0; i--) {
			a[i]++;
			if (a[i] > b[i]) {
				a[i] = 0;
			} else {
				i = -1;
			}
		}
	}
	list.add(a[0] + "." + a[1] + "." + a[2] + "." + a[3]);
	return list;
}

public static void main(String[] args) throws Exception {
	System.out.println(between("8.8.8.8", "8.8.8.8"));
	System.out.println(between("8.8.8.0", "8.8.8.1"));
	System.out.println(between("8.8.8.254", "8.8.8.255"));
	System.out.println(between("8.8.8.255", "8.8.9.2"));
	System.out.println(between("254.255.255.255", "255.0.0.3"));
}
```


Fangfrage: Wie viele IPs werden jeweils ausgegeben?


----------



## mrBrown (21. Aug 2019)

Mal ein anderer Ansatz: konvertier die IP in einen int, mit dem kannst du ganz normal zählen, und danach wieder zurück zur IP


----------



## Xyz1 (21. Aug 2019)

Oh es hat sich ein Fehler einschlichen:

```
if (a[i] > 255) {
```


----------



## chrism120 (21. Aug 2019)

Tobias-nrw hat gesagt.:


> ```
> private static LinkedList<String> between(String ipv41, String ipv42) {
> int[] a = new int[4];
> int[] b = new int[4];
> ...


eine bestimmte Anzahl hab ich nicht. das kommt auf die eingegebene  Adresse an. zB:
a= 172.16.20.1
b=172.16.21.1


----------



## Xyz1 (21. Aug 2019)

chrism120 hat gesagt.:


> an. zB:
> a= 172.16.20.1
> b=172.16.21.1


Genau, das müssten ca 255 oder 256 Anzahl sein.


----------



## chrism120 (21. Aug 2019)

Tobias-nrw hat gesagt.:


> Genau, das müssten ca 255 oder 256 Anzahl sein.


Danke sehr


----------



## Xyz1 (21. Aug 2019)

chrism120 hat gesagt.:


> Danke sehr


Also nochmal kurz...

Wenn man `if (a[i] > b[i]) {` schreibt, dann fasst er jede Komponente von b als obere Grenze auf, höhere Adressen finden keine Beachtung,
wenn man `if (a[i] > 255) {` schreibt, dann werden quasi alle Adressen die wirklich dazwischenstehen ausgegeben. 

Du kannst es aber zudem vereinfachen, mit zwei Methoden String->int[] und int[]->String.


----------



## chrism120 (21. Aug 2019)

Tobias-nrw hat gesagt.:


> Also nochmal kurz...
> 
> Wenn man `if (a[i] > b[i]) {` schreibt, dann fasst er jede Komponente von b als obere Grenze auf, höhere Adressen finden keine Beachtung,
> wenn man `if (a[i] > 255) {` schreibt, dann werden quasi alle Adressen die wirklich dazwischenstehen ausgegeben.
> ...


ok verstanden . danke noch mal


----------



## Xyz1 (21. Aug 2019)

chrism120 hat gesagt.:


> ok verstanden . danke noch mal


Kein Ding, eine Fingerübung muss auch mal sein.


----------



## mihe7 (21. Aug 2019)

Um mal den Ansatz von @mrBrown aufzugreifen:

Eine IPv4-Adresse ist einfach eine 32-Bit lange Zahl, die - für Menschen lesbar - nur in Form von a3.a2.a1.a0 dargestellt wird. Der Wert ist dann `a3*(2^8)^3 + a2*(2^8)^2 + a1*(2^8)^1 + a0*(2^8)^0` also `a3*2^24 + a2*2^16 + a1*2^8 + a0`.

Macht dann in etwa:

```
public class Test {
    public static int ipv4ToInt(String ip) {
        String[] parts = ip.split("\\.");
        int value = 0;
        for (String part : parts) {
            value = (value << 8) | Integer.parseInt(part);
        }
        return value;
    }

    public static String intToIpv4(int value) {
        return String.format("%d.%d.%d.%d",
                value >>> 24, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff);
    }

    public static void main(String[] args) {
        int value = ipv4ToInt("255.255.255.1");
        int value2 = ipv4ToInt("255.255.255.254");
        while (value != value2) { // int ist mit einem Vorzeichen behaftet, daher nicht "<"
            System.out.println(intToIpv4(value));
            value++;
        }
    }
}
```


----------



## Xyz1 (21. Aug 2019)

Genaugenommen ist das aber nicht der Ansatz, wonach gefragt wurde


----------



## mihe7 (21. Aug 2019)

Genau genommen, wurde gar nichts gefragt  

Der Unterschied zum Array ist jetzt aber nicht sooo gewaltig:

```
import java.util.Arrays;

public class Test {
    public static byte[] ipv4ToBytes(String ip) {
        String[] parts = ip.split("\\.");
        byte[] result = new byte[4];
        for (int i = 0; i < result.length; i++) {
            result[i] = (byte) Integer.parseInt(parts[i]);
        }
        return result;
    }

    public static void increase(byte[] value) {
        int ix = value.length;
        do {
            ix--;
            value[ix]++;
        } while (value[ix] == 0);
    }

    public static String bytesToIpv4(byte[] value) {
        return String.format("%d.%d.%d.%d", 
                value[0] & 0xff, value[1] & 0xff, value[2] & 0xff, value[3] & 0xff);
    }

    public static void main(String[] args) {
        byte[] value = ipv4ToBytes("255.255.254.100");
        byte[] value2 = ipv4ToBytes("255.255.255.254");
        while (!Arrays.equals(value, value2)) {
            System.out.println(bytesToIpv4(value));
            increase(value);
        }
    }
}
```


----------



## Xyz1 (22. Aug 2019)

Arrr, diese Byte-Schubserei. 



chrism120 hat gesagt.:


> das ist meine Stück kode. Diese funktioniert nicht wie erwartet. bitte Hilfe


Ich interpretiere das so: Mein Code funktioniert nicht richtig, aber wieso? Bitte verbessert ihn...

Aber, nichtsdestotrotz, hast Du und @mrBrown recht, eine IP wurde ja als 4-Byte-Zahl konzipiert... dann kann man auch simply damit rechnen


----------



## mihe7 (22. Aug 2019)

Tobias-nrw hat gesagt.:


> Arrr, diese Byte-Schubserei.


Man muss den Overflow nur zu nutzen wissen  



Tobias-nrw hat gesagt.:


> Ich interpretiere das so: Mein Code funktioniert nicht richtig, aber wieso? Bitte verbessert ihn...


Ich mach doch nur ein bisschen Spaß, natürlich steckt dahinter eine Frage  

Die hattest Du ja schon beantwortet und ich dachte mir: "Mensch, vielleicht interessiert ihn (oder andere) der Ansatz von @mrBrown auch". Außerdem schreibt jeder seinen Code etwas anders, hat seinen Stil, löst die Probleme auf unterschiedliche Weise. Davon kann man oft profitieren, wobei ich hier von mir auf andere schließe. Auf manche Dinge kommt man erst gar nicht, entweder weil man es nicht bedacht hat oder weil man die vielen Neuerungen von Java nicht alle kennt oder...


----------



## White_Fox (22. Aug 2019)

Wobei ich sagen muß, daß ich die Idee von mrBrown bestechend genial finde. Ein int läßt sich doch deutlich einfacher inkrementieren als vier Bytes.

Nur: warum macht man die Umwandlung nicht mit ByteBuffer...?


----------



## Xyz1 (22. Aug 2019)

Viele Wege führen nach Rom...


----------



## mrBrown (22. Aug 2019)

White_Fox hat gesagt.:


> Nur: warum macht man die Umwandlung nicht mit ByteBuffer...?



Hab's grad nicht genauer durchdacht, dürfte aber für den "Rückweg" unschöner werden, als shiften und maskieren. Die einzelnen Stellen bekommt man aus dem ByteBuffer ja nur als vorzeichenbehaftetes Byte, damit zu arbeiten dürfte erstmal unintuitiver sein.



EDIT:

geht eigentlich:

```
public class Test {


    public static void main(String[] args) {
        ByteBuffer value = ipv4Tobuffer("255.255.253.250");
        ByteBuffer value2 = ipv4Tobuffer("255.255.255.255");
        while (value.getInt(0) != value2.getInt(0)) { // int ist mit einem Vorzeichen behaftet, daher nicht "<"
            System.out.println(bufferToIpv4(value));
            value.putInt(0, value.getInt(0) + 1);
        }

    }

    public static String bufferToIpv4(ByteBuffer value) {
        return String.format("%d.%d.%d.%d",
                             Byte.toUnsignedInt(value.get(0)),
                             Byte.toUnsignedInt(value.get(1)),
                             Byte.toUnsignedInt(value.get(2)),
                             Byte.toUnsignedInt(value.get(3)));
    }

    public static ByteBuffer ipv4Tobuffer(String ip) {
        final ByteBuffer buffer = ByteBuffer.allocate(4);
        String[] parts = ip.split("\\.");
        for (int i = 0; i < 4; i++) {
            buffer.put(i, (byte) Integer.parseInt(parts[i]));
        }
        return buffer;
    }

}
```


----------



## chrism120 (2. Sep 2019)

Servus, ich möchte für zwei verschiedenen eingegebenen Adressen versuchen, zu prüfen ob die Rechner erreichbar sind und die aufzulisten. ich weiß, was ich falsch gemacht habe. Danke schon im Voraus für Ihre Hilfe.

```
package heritage;

import java.io.IOException;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.Scanner;

public class IPhoc {

    public static void main(String[] args) {
         int timeout=1000;
         Scanner s1,s2;
         String p1,p2;
        byte ip1[];
         byte ip2[];
        s1= new Scanner (System.in);
         System.out.println("Erste Adresse  : ");
         p1=s1.nextLine();
         System.out.println("zweite Adresse :");
         s2=new Scanner(System.in);
         p2=s2.nextLine();
         //String zu Byte konvertieren
        
        ip1= p1.getBytes();
        ip2=p2.getBytes();
        
            for (int i = 1; i < 255; i++) {
                try {
                    
                    if (!Arrays.equals(ip1, ip2)) {
                          
                           while(!Arrays.equals(ip1,ip2)) {
                        InetAddress ad = InetAddress.getByName(bytesToIpv4(ip1));
                        count(ip1);
                      
                        if (ad.isReachable(timeout)) {     
 System.out.println("Der Computer " + ad.getHostName() + " mit IP Adressse " + bytesToIpv4(ip1) + " ist erreichbar");

                            
                        }
                     /*   else {
                            System.out.println(" Der Computer ist nichr verfügbar");
                        }
                        */
                      
                                                       }
                                                  }
            
                    else {
                      System.out.println("Die Adressen müssen verschieden sein");
                      }
                    
                    
                     {
                        }
                    
                        } catch (IOException e) {}
}
    }

    // Konvertierung von IPV4 zu Byte
 public static byte[] ipv4ToBytes(String ip) {
    
    
     String[] parts = ip.split("\\.");
        byte[] result = new byte[4];
        int i=0;
        
        while (i<result.length) {
            result[i] = (byte) Integer.parseInt(parts[i]);
            i++;
            
        }
        
        return result;
 }

 public static byte[] count(byte[] value) {
        int i = value.length;
        do {
            i--;
            value[i]++;
        } while (value[i]== 0);
        return value;
    }
    // Konvertierung von Byte zu IPV4
    public static String bytesToIpv4(byte[] value) {
        return String.format("%d.%d.%d.%d",
                value[0] & 0xff, value[1] & 0xff, value[2] & 0xff, value[3] & 0xff);

    }
}
```


----------

