IPs aufteilen

[BackOrifice]

Guten Tag, Delphi Praxis!
Mein 1. Post und zwar, weil ich schnelle Hilfe brauche:

Ich soll ein Delphi 7 Programm schreiben, welches IP-Adressen zeilenweiße einließt und dadurch die Netzmaske, Netzadresse & Broadcast-Adresse bestimmt (IPs sind nach dem dotted Notation & mit angehängtem "/24" für die Netzmaske).

So gut - schon beim ersten großem Ding mein Problem:
Nach dem Einlesen einer IP(+dem Anhängsel) würde ich nun die IP aufteilen in 5 Blöcke, umwandeln in Binär, errechnen der anderen Adressen, zurückkonvertieren in normale IP-Adressen und dann ausgeben.

Wie muss ich eine IP-Adresse aufteilen?
Ich hab n bissl rumprobiert, aber nichts gefunden/gebracht.


Würde mich sehr über Hilfreiche Antworten freuen - thx im vorraus. :hi:

[Steve]

Hi,

möchtest Du (allgemein) wissen, wie eine IP-Adresse aufgebaut ist und wie man anhand der Adresse + Netzmasken-Angabe die gesuchten Informationen bestimmt?
Oder möchtest Du wissen, wie die 4 Bytes (in Delphi) zu einer 32-Bit-IPv4-Adresse umgerechnet werden?
Oder willst Du was ganz anderes? :mrgreen:

Gruß
Stephan :dance:

edit: Herzlich willkommen in der Delphi-PRAXiS! :dp: :party:

[BackOrifice]

Hiho (;

Nein, nein - wie eine IP-Adresse aufgebaut ist & man die zugehörigen Netzmasken usw. bestimmt, weiß ich.
Es geht darum, wie ich nun an die einzelnen "Blöcke" der IP Adresse rankomme (eben um Netzteil & Hostteil zuverändern).

Ich hab mir gedacht, ich teil die ganzen Kram auf; in 5 gleich große Blöcke aus String, die dann jeweils einen Block repräsentieren. Wie ich's mir gedacht hab, hat nicht funktioniert.
Deswegen bin ich mittlerweile schon so weit, dass ich nur noch einen String nehme (ohne . und /), also nur noch die Zahlen - aber mir schmiert das Programm mit Stack Overflow ab.


Irgend ne Idee für nen armen kleinen programmierer? *g*

[Sharky]

Hai BackOrifice,

eine IP-Adresse hat ja immer das Format:

A.B.C.D

Jeder Block (Oktet) besteht aus 8-Bit. Die Netzadresse ist nur gerade der Teil der IP-Adresse beinen alle BITs der Subnetzmaske 1 sind. Duch eine AND-Verknüpfung bekommst Du die Netzadresse. Uff.. was ein Satz ;-)

Beitspiel:

Code:

IP          : 192.168.001.001
SN          : 255.255.255.255

Binär ist das:

IP          : 11000000.10101000.00000001.00000001
AND
SN          : 11111111.11111111.11111111.00000000
Netzadresse : 11000000.10101000.00000001.00000000

              192     . 168    . 1      . 0

Die Subnetzmaske wird ja durch die IP-Adresse vorgegeben (wenn ich das Subnetting einmal unberücksichtigt lasse.

[BackOrifice]

Vielen Dank.. - aber das weiß ich doch schon :cry:
Die Information, wie ich Broadcast usw.. bestimme, habe ich. Es geht darum, wie ich das Problem im Quelltext am Besten löse.

Und da gehts jetzt los: Ich muss (zumindest glaube ich das) die IP-Adresse in ihre 4 (+ den 5. für die Netzmaske) Blöcke aufteilen. Diese Blöcke dann schließlich konvertieren in Binär; Operationen zu den Adressen durchführen (wie du schon sagtest mit and/or usw.) und schließlich wieder zurück wandeln in eine normale IPv4 Adresse.

Kurz und knapp gesagt: Ich habe keinen Plan, wie ich an einem Block der IP-Adresse rankomme um dort was verändern zu können.


Hoffe nochmals auf Hilfe :drunken:

[Steve]

Hi,

ich glaub, ich versteh nu, was Du meinst :mrgreen:

Delphi-Quellcode:

var
  IP : Longword;   // IP -> Longword deshalb, weil 32-bittig
begin
  // Initialisieren
  IP := 0;
  // IP-Adresse aus den 4 Bytes zusammensetzen
  IP := Byte(IP_Block_1) SHL 24 + // 1. Block mit 8 Bit Länge um 24 Bit nach links verschieben
        Byte(IP_Block_2) SHL 16 + // 2. Block mit 8 Bit Länge um 16 Bit nach links verschieben
        Byte(IP_Block_3) SHL  8 + // 3. Block mit 8 Bit Länge um  8 Bit nach links verschieben
        Byte(IP_Block_4);         // 4. Block mit 8 Bit Länge bleibt "ganz hinten" stehen
end;

Wie IP-Adressen aufgebaut sind etc. scheint ja klar zu sein, darum nur dieser kurze Code.
Um die IP-Adresse aus den einzelnen Blöcken zusammensetzen zu können, brauchen wir eine 32-bittige Variable (hier "ip").
IP_Block_1 bis IP_Block_4 sind die 4 Blöcke, die definitionsgemäß Werte von 0 bis 255 annehmen können, da sie ja einzelne Bytes repräsentieren. Ich habe nochmal einen Typecast nach Byte dazugeschrieben, wenn IP_Block_x schon vom Typ Byte ist, kann das natürlich wegfallen.
Mittels SHL werden die Bytes nun an ihre "Position" innerhalb der 32-Bit-IP verschoben.

Ich hoffe, das hilft Dir etwas weiter :)


Edit: Die Netzmaskenangabe, z.B. /24 wird nicht umgewandelt. Die Zahl gibt ja nur an, wie viele Bits der Adresse der Netzadresse angehören. Das heißt, für /24 besteht die Netzmaske aus 24x "1" und die restlichen 8 Bit sind "0":

Code:

11111111 11111111 11111111 00000000

Die entsprechende Zahl kannst Du Dir in einer Schleife zusammenbasteln:

Delphi-Quellcode:

// NetzAnteil wäre z.B. 24
// Initialisieren
Maske := 0;
// 32 Bit 
FOR Stelle := 1 TO 32 DO
  // Im "Netzbereich" der Adresse?
  IF Stelle > 32-NetzAnteil THEN 
    // Maske zusammensetzen
    Maske := Maske + (1 SHL Stelle);

Um die Netzadresse zu erhalten, einfach IP-Adresse und Netzmaske AND-verknüpfen, d.h. wenn Du IP und Maske z.B. als Longword vorliegen hast, reicht schon:

Delphi-Quellcode:

Netzadresse := IP AND Maske;

Gruß
Stephan :dance:

[Sharky]

Du hast also einen String der so aussieht:

192.168.1.88/24

So, was möchtest Du nun machen?

Du möchtest jedes Oktet in einer eigenen Integer (Byte) Variablen haben!
Du kannst also einfach mit Pos und [oh]Copy[/b] den String aufteilen.

[Phistev]

Diese Funktion sollte dir helfen, in Kombination mit IntToStr.

[BackOrifice]

Ich danke euch dreien. Aber ich glaub, ich raff's irgendwie nicht :wall:

Die Idee von Steve, die IP in einem Longword zu speichern, ist sicherlich gut; aber ich habe eben genau diese 4 Blöcke nicht bzw. schaffe es nicht, sie zu erstellen. :pale:

Ich habe eine IP im String nach folgendem Muster: 192.168.1.88/24
Und ich schaffe es nicht, diesen String in 4 weitere zu unterteilen, wobei (wie ihr ja schon erkannt habt) jeder Oktav in einem eigenem String oder auch integer sein soll.

Ich kriegs einfach nicht hin -.-

//e: eine Blödheit ist mir schon peinlich :oops:

[xineohp]

hi,

wie schon erwähnt wurde benötigst du nur die Funktionen pos() bzw. posEx() und copy.
Die FUnktion von Phistev wird dir wohl nicht weiter helfen, da sich das Trennzeichen ändert.
Also ist selber machen angesagt :mrgreen:

Delphi-Quellcode:

uses
  StrUtils;
var
  p1,p2,p3,p4: integer;
  block1,block2,block3,block4,block5: string;
  IP: string;
begin
  IP := '123.456.789.123/25';

  p1 := posex('.', IP, 1);
  p2 := posex('.', IP, p1+1);
  p3 := posex('.', IP, p2+1);
  p4 := posex('/', IP, p3+1);

  block1 := copy(IP, 1,    p1-1);
  block2 := copy(IP, p1+1, p2-p1-1);
  block3 := copy(IP, p2+1, p3-p2-1);
  block4 := copy(IP, p3+1, p4-p3-1);
  block5 := copy(IP, p4+1, length(IP)-p4); 

  showmessage( block1 +#13#10+
               block2 +#13#10+
               block3 +#13#10+
               block4 +#13#10+
               block5 );
end;

[BackOrifice]

Danke Schöööööön :dancer2:

[BackOrifice]

Ich hab' nochmal ne Frage :D
Wollte dazu keinen neuen Thread aufmachen, weils relativ kleines Prob ist:

Ich habe 2 IP Adresse im Binären String; durch eine AND-Operation ergibt sich daraus eine neue (binäre) IP-Adresse.
Beide Adressen sind jeweils nur 32bit groß und trotzdem schmiert mir jedes mal das Programm ab ('111111111110100101010101010usw.. ist kein gültiger Integerwert').

Ich hab bereits schon INT64 versucht, bringt leider nichts :?

Hiermal n kleiner Ausschnitt ausm Quelltext (inzwischen so oft umgeändert..):

Code:

function Netzadresse (IP_adresse_bin, Netzmaske_bin : string) : string;
var  Netz1,Netz3,Netz4 : int64;
     Netzadresse_2 : string;
begin
  Netz1:=0;      //<-- auch sehr lustig: Nach der Anweisung hat die Var immer noch einen Wert von -48546453
  Netz1:=StrToInt(IP_adresse_bin);     //<-- ab hier der Abbruch
  Netz3:=StrToInt(Netzmaske_bin);
  Netz4:=Netz1 and Netz3;
  Netzadresse_2:=IntToStr(Netz4);
  ShowMessage('Netzadresse: ' + Netz2);
  Netzadresse:=Netzadresse_2
end;

Jmd. ne Idee? :angel2:

[Waldteufel]

Hi.

Du kannst nur Strings, die eine Zahl im Dezimalsystem beinhalten nach integer konvertieren. ;-)

[BackOrifice]

Und nun? :wiejetzt:

Gibts ne Möglichkeit, diesen Umstand zu umgehen? Irgend nen Trick? ;)

[Waldteufel]

Hi.

So müsste es gehen: (ungetestet)

Delphi-Quellcode:

function BinStrToInt(str : string) : integer;
var
  i : integer;
begin
  result := 0;
  for i := 1 to Length(str) do
    result := result + ( (Ord(str[i]) - Ord('0')) * Power(2, Length(str) - i) );
end;

Konvertiere die Zahlen einfach mit BinStrToInt(i) statt StrToInt(i) ;-)

[Phistev]

Kleine Anmerkung am Rande: die Funktion kann weiterhelfen, wenn man weiß wie

Delphi-Quellcode:

var ip, temp TStringDynArray;
    suffix: string;
begin
  temp:= Explode('/',Adresse);
  suffix:= temp[1];
  ip:= Explode('.',temp[0]);
//Ip[0] bis ip[3] => die vier Blöcke
//suffix => der Teil nach dem Schrägstrich

Ein String aus dem Array kann man auch an Explode übergeben :mrgreen:

[BackOrifice]

Danke danke - aber als was definierst du die Funktion "Power"? :angel:

//e: Thx Phistev, aber so kompiliziert wollt ichs nicht machen *g*

[Waldteufel]

Hi.

Huppsala... :oops:

Delphi-Quellcode:

uses {...}, Math, {...};

fehlte noch... :oops:

[BackOrifice]

narf, Inkompatible Typen: Integer und Extended :?
Und eine Funktion á la IntToExt hab ich leider auch nicht gefunden :cry:
Trotzdem danke nochma ;)

[alcaeus]

Nun, da in diesem Fall sicher ein Integer rauskommt, kann man das Ergebnis von Power ganz einfach mit Trunc in einen Integer verwandeln. Dabei werden alle Nachkommastellen abgeschnitten. Falls gerundet werden soll, so verwendest du einfach Round. Du musst also nicht int nach extended casten (das muss man gar nicht, in die Richtung sind die Typen sogar kompatibel), sondern umgekehrt ;)

Greetz
alcaeus