Anzahl Clients aus Start- und Endadr. berechnen

[MAGIo]

Hallo, wie kann ich bei gegebener Startadr. und Endadr. durch Benutzereingabe daraus die Anzahl der theoretischen Clients im Netz berechnen? Ich denke die Umrechnung in Bytes könnte mich da weiterbringen, doch muss das ja ein allgemein gültiger Rechenweg sein, da ja unterschiedliche Eingaben je nach Netzklasse gemacht werden. Alternativ ginge es ja auch über die zusätzliche Eingabe der Subnetzmaske.

Ich denke Ihr hattet sowas schonmal, gefunden habe ich leider nichts.

Bitte helft mir da weiter, VG

 

[chalkbag]

An sich brauchst du um die Anzahl der theoretisch möglichen Clients nicht zwangsweise Start u. Endaddresse angeben, auch die Subnetzmaske brauchst du nur beim Subnetting.

Über die führenden Bits, weißt du ja welches Netz du vor dir hast, und wieviel Clients du maximal addressieren kannst.

 

[Eldar]

Du ziehst die Startadresse von der Endadresse ab (z.B binär). Dann nur noch -2 für Netz- und Broadcastadresse.

Beispiel:
Anfangsadresse
192.168.4.0
11000000 10101000 00000100 00000000
Endadresse
192.168.12.255
11000000 10101000 00001100 11111111


Rechnung
1100 11111111
-0100 00000000
=1000 11111111
=2303
Sind also 2303 Adressen also 2301 mögliche Clients

 

[MAGIo]

Du ziehst die startadresse von der Endadresse ab (binär)

Komplett? Und die bin. Differenz stellt die anzahl der mögl. Clients dar?

 

[Eldar]

Hab mal eine Beispielrechnung eingefügt. Nicht vergessen, dass die erste und die letzte Adresse nicht an einen Client zu vergeben sind.

edit: Mir fällt zumindest auf Anhieb keine Kombination ein bei der das nicht klappen würde.

 

[MAGIo]

Bin es rechnerisch durchgegangen und ist ja auch logisch, wenn man sich den prinzipiellen Aufbau anschaut. Jedoch ist dann noch der Unterschied zwischen Theorie und Praxis...


Also.. WIE RECHNE ICH DIE IP ADR. IN DUALZAHLEN ODER BYTES UM?

 

[Eldar]

Wie genau bekommst du sie denn?
Ist vielleicht die Eingabemaske schon entsprechend aufgebaut (4 Felder für Zahlen zwischen 0 und 255)?
Oder bekommst du sie als String (ein Eingabefeld für alle möglichen Zeichen)?
oder wie?

Schau dir mal java.net.InetAdress an.

 

[MAGIo]

Ich bekomme den String und nutze InetAddress address = get........

Nur weiss ich nicht wirklich, wie ich daraus die Bitfolge bestimmen kann dann.

 

[Eldar]

byte[] getAddress() schon hast du die Oktette. Bissl umwandeln..
Integer.toBinaryString().

Oder willst du lieber per Hand rechnen?

 

[MAGIo]

ich setze mich morgen frueh da wieder dran und versuch es. Melde mich dann, aber vielen Dank.

 

[MAGIo]

     byte[] rawaddr = address.getAddress();  
     Integer.toBinaryString(i);

Da fehlt ja der Zwischenschritt, wie schaffe ich es denn, daraus ein Integer zu machen, sodass ich es zum BinaryString umwandeln kann?

 

[HoaX]

Indem du die Bytes aus rawaddr aneinander hängst.

rawaddr[0] << 24 | rawaddr[1] << 16 | ...

 

[MAGIo]

Konkret als Code bedeutet das? Ich krieg nur Wirrwarr heraus!
Zudem krieg ich als Rawaddr. schon negative Zahlen, was ja nicht sein kann...

     System.out.println( Integer.toBinaryString(rawaddr[0] << 24 | rawaddr[1] << 16 | rawaddr[2] << 8 | rawaddr[3] << 0 ) );

genial... wenn ich noch wuesste, wieso?

 

[HoaX]

Wieso sollten sie positiv sein? Kommt halt drauf an wie man sie interpretiert.

Ab besten du informierst dich erstmal über die binäre Darstellung von Zahlen und Bit-Operatoren.

 

[MAGIo]

Funktioniert Alles, bis auf...

Wie bestimme ich die Netzklasse? Mir ist klar, dass anhand der einleitenden Bits diese bestimmen kann, das wird ja sicherlich schon jemand so gemacht haben. Es ist ja nun praktisch, dass ich die Umrechnung in Bits vorgenommen habe.

 

[HoaX]

Schau dir doch mal die binäre Darstellung der Netzklasse an... mit ein bisschen nachdenken (oder googlen) kommst du drauf.

 

[MAGIo]

Ich habe das altbekannte Problem, dass die Umrechnung fuer IP Adresse ueber +127 natuerlich was Falsches herauskommt. Hatte es in einem FIrmennetz getestet, daher ist der Fehler nicht aufgefallen. Wie loese ich das denn nun?

 

[HoaX]

Rechne halt mit int statt byte?! Bzw sollte die Rechnung idR trotzdem funktionieren, du musst nur am Ende passend auf int umwandeln:

byte b = -1; 
int i = b & 0xff; // ergibt i = 255

 

[MAGIo]

Ich probier schon den halben Tag rum... Es wird mal wieder was ganz simples sein, nur verliert man bei Fehlern dann auch schnell und leicht den Ueberblick und dann wirds kritisch...

Ich probier mal rum, bg

 

[MAGIo]

Also irgendwas stimmt hier nicht, bei mir

zB krieg ich bei einer IP Adresse mit 192. ... den Beginn mit 11111111.... und bei 10.10. 1010...

Ich verstehe auch Deine Ausfuehrung am Ende, nur wie soll ich das einbringen bzgl. Umrechnung im Programm?

Ich konkretisier es mal anhand eines Codeschnipsels:

       System.out.println( "IP Startbereich eingeben:" ); //Aufforderung zur IP Eingabe
       BufferedReader in = new BufferedReader( //Streamen der Eingabe als Eingabestream
       new InputStreamReader( System.in )); //Erstellen des Eingangsstreams
       start = in.readLine(); //liest komplette Zeile ein und speichert als String start       
  	 System.out.println( "IP Endbereich eingeben:" ); //Aufforderung zur IP Eingabe
     end = in.readLine();     //liest komplette Zeile ein und speichert als String end 
     InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
     byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
     binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0 ));
     InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = addrend.getAddress(); //Umwandlung der Endadresse in Bitoperatoren RAW
     System.out.println(Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) );

 

[HoaX]

Zeig doch mal deine Idee und ggf. Code wie dus versuchst ...
Wie du die IPs einliest ist doch völlig irrelevant.

 

[MAGIo]

     binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0 ));
     InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = addrend.getAddress(); //Umwandlung der Endadresse in Bitoperatoren RAW
     System.out.println(Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) );
     raw = ((rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0))-((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0)); //Bestimmung der RAW Differenz in Variable raw
     clients = ++raw;//Bestimmung der Testanzahl
     binend = ( Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) ); //Ausgabe der binary Endadresse
     System.out.println(binstart);
     System.out.println(binend);

Klar, aber integrativer Bestandteil der Ausgabe

 

[HoaX]

Also den Code zu lesen macht mal null Spaß, nutz doch mal ordentliche Variablennamen und Formatierung und mach nicht immer so viele Schritte in einer Zeile ... und dann mach dir einen Test der z.B. so anfängt:

long startAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 0;
long endAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 255;

Damit rechnest du dann. Dann kann man das auch einfach mal hier herauskopieren und ausprobieren. So muss man ja erstmal 10 Zeilen anpassen und Variablen deklarieren usw ...

Nachtrag: Deine Idee wie du nun auf die Netzmaske kommst ist bislang auch noch nicht enthalten. Tipp zur einfachen Berechnung: xor

 

[MAGIo]

Ja, hab ich gemacht. Das Splitten wollte ich bei erfolgreichem Ablauf machen, weil ich irgendwie tausend Gedanken gleichzeitig habe um das noch besser zu machen. Natuerlich leidet dann die Uberesichtlichkeit und die Funktionalitaet wird nicht unbedingt besser...

Trotzdem, ich denke der Punkt ist bei

     InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
     byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
     binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3]));

 

[MAGIo]

Naja, die Klassifizierung des Netzes scheint ja zu klappen, habe das mit einer mehrfahren IF Verzweigung geloest, nur ist die Berechnung der binaeren Darstellung zumindest fuer die ersten beiden Trippel falsch, denn fuer zB 192 wird 11111111 ausgegeben, was ja nciht sein kann und aufgrund der unsigned Bytes entsteht.

 

[HoaX]

Welcher Punkt? Schreib doch mal komplette Sätze was nicht geht, mit konkretem Code der genau das zeigt was du da versuchst und nicht geht, und dann am Besten wie ich oben schon sagte ohne Firlefanz der uninteressant ist.
Erst kommt der Test mit statischen Daten zum Testen, und wenn dann das System zu berechnung steht dann kommt das nächste Teilproblem dran und ganz am Ende wird das erst kombiniert. Spart dir viel Kopfzerbrechen weil du dich aufs wesentliche Konzentrieren kannst: Das Problem.

Nachtrag:

... nur ist die Berechnung der binaeren Darstellung zumindest fuer die ersten beiden Trippel falsch, denn fuer zB 192 wird 11111111 ausgegeben

Wie berechnet du die?

... , was ja nciht sein kann und aufgrund der unsigned Bytes entsteht.

Wie kommst du darauf?


Nachtrag2: Komm doch mal in den Chat ...

 

[MAGIo]

Also ich schaffe es nicht die Umwandlung der eingegebenen IP Adresse als Bitfolge richtig umzusetzen. Die nachfolgenden Berechnungen und Bestimmungen funktionieren, aber eben getestet anhand falsch umgewandelter Daten. Konkretes Beispiel ist Folgendes:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {

	/**
	 * @param args
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException {
	     String start = "192.168.178.1";
         
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
	     
         String binaddress = Integer.toBinaryString((rawaddress[0] << 24 | rawaddress[1] << 16 | rawaddress[2] << 8 | rawaddress[3]));
	System.out.println(binaddress);
	}

}

 

[HoaX]

Ganz einfach:
* rawaddress[0] ist ein Byte, negativ wie du vorhin schon angemerkt hast (da >127), also solltest du das erstmal in eine positive Zahl umwandeln. (Siehe http://www.java-forum.org/742896-post18.html)
* << ergibt eine negative Zahl, da ja nun das erste Bit gesetzt ist -> größeren Datentyp wählen -> long

byte b = (byte) 192;
long l = (long)(b & 0xff);
long x = l << 24;

Ergibt dann 11000000.00000000.00000000.00000000

 

[MAGIo]

Tut mir leid, danke fuer deine Hilfe. Ich moechte ja nichts vorgekaut haben und waere froh das aus eigener Kraft zu schaffen, doch stehe ich total auf dem Schlauch. Dein Beispiel hab ich natuerlich verstaendlich gecoded, doch reflektiert auf meins ist es mir fast unmoeglich einen fehlerfreien Ablauf hinzukriegen. Ich demonstriere es mal:

Das Beispiel als vollstaendiger Code:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {


	public static void main(String[] args) throws UnknownHostException {
/*	     String start = "192.168.178.1";
         
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
*/         
     	byte b = (byte) 192;
    	long l = (b & 0xff);
    	long x = l << 24;
         String binaddressb = Long.toBinaryString(b);
         String binaddressl = Long.toBinaryString(l);
         String binaddressx = Long.toBinaryString(x);
	System.out.println(b);//-64
	System.out.println(l);//192
	System.out.println(x);//3221225472
	System.out.println(binaddressb);//1111111111111111111111111111111111111111111111111111111111000000
	System.out.println(binaddressl);//11000000
	System.out.println(binaddressx);//11000000000000000000000000000000
	}

}

und nun fuer meinen Fall

     InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = ((byte[])addrend.getAddress()); //Umwandlung der Endadresse in Bitoperatoren RAW
     long[] rawaddrelong = (rawaddre[0] & 0xff);

...?

 

[HoaX]

Dein rawaddrlong ist doch ein Array, also muss es dann heißen:

long[] rawaddrelong = { rawaddre[0] & 0xff, rawaddre[1] & 0xff, rawaddre[2] & 0xff, rawaddre[3] & 0xff };

Danach brauchst du nurnoch die Longs nurnoch zusammenfügen.

 

[MAGIo]

JUHU!! Es klappt, das Problem lag auch an den unverstaendlichen Fehlermeldungen und dann irgednwann der verlorenen Uebersicht. Mit ein bisschen Struktur sieht es doch direkt viel einfachcer aus

 

[HoaX]

Dann is ja gut.
Rechnung kommt per Post ...

 

[MAGIo]

Es geht noch weiter, aber vorher gehe ich erstmal schematisch (wie eben beigebracht) vor und falls ich nicht weiterkomme mit detaillierter Fehlerbeschreibung und dem Code

Hoffentlich (NICHT) bis gleich...

 

[MAGIo]

Und weiter gehts....

Ich moechte den Ablauf fuer mehrere IPs innerhalb einer Range machen, habe nun mehrere Ansaetze. Ich koennte den Binarycode jeweils mit der umgewandelten Binarydarstellung des zusaetzlichen Hosts addieren, dann muesste ich aber die Tests auch mit dem Binarycode machen vorher.

Daher waere es natuerlich ganz praktisch die Veraenderung der getesteten Adresse schon jeweils vorher zu machen, bevor ueberhaupt die ganzen Umwandlungen und Tests stattfinden und das schoen in einer Schleife verpacken. Ich habe mal ein paar kleine Testdurchlaeufe gecodet, komme aber auf kein Ergebnis so richtig, da ja das IP Adressformat beachtet werden muss (Maximale Anzahl der Hosts im Trippel) usw...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {


	public static void main(String[] args) throws UnknownHostException {
/*	              
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
         long[] rawaddresslong =  { rawaddress[0] & 0xff, rawaddress[1] & 0xff, rawaddress[2] & 0xff, rawaddress[3] & 0xff };
*/      
		
		String start = "192.168.178.1";
	    InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
	    
		short i=298;	    
	    byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
	    long[] rawaddrslong = { rawaddrs[0] & 0xff, rawaddrs[1] & 0xff, rawaddrs[2] & 0xff, rawaddrs[3] & 0xff };
	    String binstart = Long.toBinaryString(rawaddrslong[0] << 24 | rawaddrslong[1] << 16 | rawaddrslong[2] << 8 | rawaddrslong[3]); //Ausgabe der binary Startadresse
	    String binoffset = Long.toBinaryString(i); //Ausgabe der binary Startadresse


     	byte b = (byte) 192;
    	long l = (b & 0xff);
    	long x = l << 24;

         for (i=0; i<=5;i++)
         {
         	long c = l+i;
        	 System.out.println(c);
         }
	System.out.println(l);
	System.out.println(addrstart);
//	System.out.println(addrstart2);
	System.out.println(binstart);//ADDITION DER BIN CLIENTS
	System.out.println(binoffset);
	System.out.println(binstart+binoffset);

	}

}

 

[HoaX]

Ich versteh nur Bahnhof was du eigentlich machen willst ...

 

[MAGIo]

mit den bestimmten Clients einfach nen Ablauf schaffen, dass jede Adresse innerhalb der IP Range durchlaufen wird, also immer ++

 

[HoaX]

Und was ist da jetzt das Problem?

Grad schreibst du, dass du die Adressen zwischen zwei bestimmten Adressen durchlaufen willst (wenn ich dich richtig verstanden habe). Einen Post vorher steht da noch was von Tests ... entscheide dich was du willst, und drück dich klar aus.

Start- und Endadresse als "long" berechnen solltest du ja mitterweile wohl hinbekommen. Was fehlt ist einfach nur nen +1 auf die Startadresse solange diese kleiner als die Endadresse ist.
Ich seh jetzt immer noch nicht wo jetzt dein Problem liegt...

 

[MAGIo]

Ja, so ist es logisch. Ich hatte eigentlich gedacht die Differenz auszurechnen und diese jeweilis zu erhoehen, doch da waeren Ausnahmen faellig und es waere ja dohc komplizierter. Ich versuche mal Deinen Tipp.

Die Tests etc. gingen ja um die Binaerdarstellung der IPs, das laeuft unabhaengig des geposteten und funktioniert. Hab ja einen Testfall geschrieben, damit es einfacher nachzuvollziehen ist

 

[MAGIo]

             for (int i = 0; rawaddrslong<=rawaddrelong;i++)
     {
    	 System.out.println(rawaddrslong+i);
     }

So in etwa, nur ohne Fehlermeldungen

 

[MAGIo]

Wie soll ich eigentlich die Long Arrays inkrementieren, sodass es allgemein immer passt? Ich kann doch auch mehr als 256 (-2)Clients im Netz haben...

 

[MAGIo]

Ich stehe aktuell bei folgendem Code, aber zum Funktionieren krieg ich gar nix....

int clients = 10;
rawaddrs[clients]++;
int carry = rawaddrs[clients] == 0 ? 1 : 0;
while (clients-- > 0) {
	rawaddrs[clients] += carry;
	carry = carry > 0 && rawaddrs [clients] == 0 ?1 : 0;}

 

[chalkbag]

Ich geb zu, ich hab den Thread nicht mehr genauer verfolgt, vielleicht hat dir wer den Code so gegeben.
Aber bei den Code-Konstrukten halte ich eine zu frühe / zu späte inkrementierung /dekrementierung für durchaus wahrscheinlich.


Aber was heißt denn genau, funktioniert nicht?

[Edit]

carry = carry > 0 && rawaddrs [clients] == 0 ?1 : 0;}

würde er nicht hier versuchen einen boolean der int Variablen zuzuweisen?

 

[Andi_CH]

Ich geb zu, ich hab den Thread nicht mehr genauer verfolgt, vielleicht hat dir wer den Code so gegeben.
Aber bei den Code-Konstrukten halte ich eine zu frühe / zu späte inkrementierung /dekrementierung für durchaus wahrscheinlich.


Aber was heißt denn genau, funktioniert nicht?

[Edit]

carry = carry > 0 && rawaddrs [clients] == 0 ?1 : 0;}

würde er nicht hier versuchen einen boolean der int Variablen zuzuweisen?

Vernünftig geschrieben heisst das:

if (carry > 0 && rawaddrs [clients] == 0)
  carry = 1;
else
  carry = 0;

Ich sage es zum 100 und ersten mal - die ?: Schreibweise ist erbärmlich zu lesen und gehört verboten.

 

[HoaX]

Du hattest doch weiter vorne im Thread bereits longs erzeugt welche die 4 Bytes enthalten. Jetzt musst du doch nurnoch vom Einen zum Anderen iterieren und den Long zurück umwandeln ...

long start = ...;
long end = ...;

while(start < end) {
    int b1 = (start >> 24) & 0xff;
    int b2 = (start >> 16) & 0xff;
    int b3 = (start >> 8) & 0xff;
    int b4 = start & 0xff;

    System.out.println(String.format("%d.%d.%d.%d", b1,b2,b3,b4));
    start++;
}

 

[MAGIo]

Die ? Schreibweise hatte ich selber nicht verstanden, habe mir naemlich die Sache zusammengebastelt. Wenn der Kaffee wirkt, setze ich mich mal dran und poste mein Ergebnis. Bis spaeter

 

[Andi_CH]

Brauchst nicht mehr viel zu denken - ich habs ja umgeschrieben ;-)

Ich hol mir jetzt meinen dritten Kaffee von heute.

 

[MAGIo]

	    byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW
		long[] rawaddrslong = { rawaddrs[0] & 0xff, rawaddrs[1] & 0xff, rawaddrs[2] & 0xff, rawaddrs[3] & 0xff };
		byte[] rawaddre = addrend.getAddress();  //Umwandlung der Endadresse in Bitoperatoren RAW 
	    long[] rawaddrelong = { rawaddre[0] & 0xff, rawaddre[1] & 0xff, rawaddre[2] & 0xff, rawaddre[3] & 0xff };
		 

	    while(rawaddrslong < rawaddrelong) 
	    {
	        int b1 = (int) (rawaddrslong[0] >> 24);
	        int b2 = (int) (rawaddrslong[1] >> 16);
	        int b3 = (int) (rawaddrslong[2] >> 8);
	        int b4 = (int) (rawaddrslong[3]);
	     
	        System.out.println(String.format("%d.%d.%d.%d",b1,b2,b3,b4));
	        rawaddrslong[0]++;
	    }

Fast... aber bisher nichts ausser Fehlermeldungen

 

[HoaX]

Wenn man falsch abschreibt, dann kann das schon vorkommen...

 

[MAGIo]

hab das doch per copy and paste und dn auf meinen fall angewendet... was meinst du genau?

 

[MAGIo]

ich erzeuge doch long arrays [] mit den einzelnen Bytes

	public static void main(String[] args) {
		long start = 192;
		long end = 200;
		 
		while(start < end) {
		    int b1 = (start >> 24) & 0xff;
		    int b2 = (start >> 16) & 0xff;
		    int b3 = (start >> 8) & 0xff;
		    int b4 = start & 0xff;
		 
		    System.out.println(String.format("%d.%d.%d.%d", b1,b2,b3,b4));
		    start++;
		}

	}

Ich habe das parse auf int weggemacht, nur so wie hier beschrieben funktioniert es einfach nicht!

String.format ist fuer diese Variante nicht ausfuehrbar und bei den jeweiligen variablen kann er nicht von long auf int