Mit IP-Adressen rechnen...

[SaltJohn]

Ok ein wenig blicke ich durch. Man kann also über WinSock die einzelnen Oktetts des IP-Strings ansprechen.

s_b4 := Chr(Ord(s_b4) + 100); // ASCIIcode von(Binärzahl des 4.Oktetts + 100(dez)) Korrigiere mich bitte wenn falsch liegen.

[Tod787]

Hi, habe da etwas ähnliches vor.
Ich würde gerne die Wahl des zu ändernden Byte variabel lassen also der Funktion einen Eingabeparameter geben um Byte 1-4 auszuwählen.

Eigentlich bräuchte ich doch nur eine Möglichkeit s_b4 mit einer Verknüpfung variabel zu machen( Bsp. s_b + Übergabeparameter). Bloss wie wandle ich die Variable um?
Habe im Code unten mal die Funktion mit Parameter. "s_bx" soll hier die Variable sein die mit dem Übergabeparameter das richtige Byte der IP ansprechen soll.

Delphi-Quellcode:

procedure TForm1.Button5Click(i: Integer); 
var   inAddr: TINAddr;
      s_bx : string;
begin
      IPAdresse := Edit1.Text;
      inAddr.S_addr := inet_addr(PChar(IPAdresse)); 
      s_bx := 's_b'+intToStr(i);         // HIER DER STRING WELCHER NOCH UMGEWANDELT WERDEN MUSS 
      with inAddr.S_un_b do
         s_bx := Chr(Ord(s_bx) + FOffset);          
      IPAdresseOffset := inet_ntoa(inAddr);      
end;

Am Besten wäre es natürlich wenn es etwas wie Gibt es etwas wie StringToxxx(s_bx) geben würde

Edit: Eine Möglichkeit wäre natürlich das mit Case of... zu machen

[SaltJohn]

Hi Tod787, Sorry aber da kann ich dir nicht weiterhelfen. Höchstens mit einer Case...of Anwendung aber da bist du ja schon selbst draufgekommen

[sirius]

eine IPv4 Adresse ist nix anderes als eine 32bit Zahl (Cardinal)

Delphi-Quellcode:

function add2Addr(addr:String; Pos:Byte; count:Integer):string;
var inAddr:cardinal;
begin
  inAddr:=inet_addr(PChar(Addr)); //Umwandeln in Integer (Achtung! ist Big Endian)
  Pos:=pos*8; //pos*8bit ergibt das gesuchte Byte
  inc(inAddr,count shl pos); addieren und dabei count an die richtige Position schieben
  result:=inet_ntoa(in_Addr(inAddr)); //zurückwandeln
end;

Pos = 0..3 (0 ist die erste Stelle 3 die Letzte)

[Tod787]

Danke klappt wirklich gut soweit. Was mich noch beschäftigt ist eine Art Überlaufkontrolle einzurichten. Ich meine wenn der Offset zu hoch gewählt wurde und die Zahl über 254 geht ist es ja jetzt so dass bei der Umwandlung einfach wieder bei 0 angefangen wird.

Edit: Ich müsste doch quasi nur ab dem gewünschten Oktett 8 bits zählen und deren Wert mit 255 vergleichen. Bloß wie komme ich an die 8 Bit ran?

Was mich auch wundert ist dass die Zahl 255 nicht erreicht werden kann.

[sirius]

Welche Lösung hast du denn jetzt gewählt?

[SaltJohn]

Also ich würde die letzte nehmen

Edit: Die anderen sind aber auch ok

[sirius]

InAddr ist eine 32-Bit-ZAhl
Die IP 255.255.255.255 wird als $FFFFFFFF dargetsellt
IP 255.0.0.0 ist $FF000000
IP 0.0.0.255 ist $000000FF
usw. usf.
Und damit kannst du jetzt rechnen.

Wenn du zu Beispiel die erste Stelle haben willst, dann machst du
(inAddr and $FF000000) shr (3*8)
bzw
(inAddr and ($FF shl (3*8)) shr (3*8)
Anstatt der 3 kannst du dann die anderen Positionen einsetzen.


Edit: Verdammt aus "8)" wurde ja ein Smiley

[Tod787]

Hab das leider nur halb verstanden. Habe mir eine Lösung mit deiner Methode überlegt allerdings funktioniert diese nur mit dem ersten Byte meiner IP-Adresse.

Delphi-Quellcode:

var
    inAddr: cardinal;
    inAddr_bkup: cardinal;
    Originalbyte: Integer;
    Offsetbyte: integer;
   
begin
    inAddr := inet_addr(PChar(FAdr));   // Umwandeln in Zahl
    inAddr_bkup := inAddr;             // Zahl merken
    pos := pos * 8;                   // pos*8(bit) ergibt das gesuchte Byte
    inc(inAddr,count shl pos);        // addieren und dabei den Offset in Byte schieben
    Originalbyte := (inAddr_bkup and $FF000000) shr (pos);    // Wert des Originalbyte bestimmen
    Offsetbytet := ((inAddr and $FF000000) shr (pos));      // Wert des Bytes mit Offset bestimmen
    if Offsetbyte = Originalbyte + count then   // Wenn Offsetbyte = Originalbyte+Offset 
      result := inet_ntoa(in_Addr(inAddr))      // zurückwandeln
    else showmessage('Offset zu groß')          // sonst Fehlermeldung
end;

Edit:

Es hat doch noch funktioniert

mit deiner zweiten Methode geht

Delphi-Quellcode:

var
    inAddr: cardinal;
    inAddr_bkup: cardinal;
    Originalbyte: Integer;
    Offsetbyte: integer;
   
begin
    inAddr := inet_addr(PChar(FAdr));   // Umwandeln in Zahl
    inAddr_bkup := inAddr;             // Zahl merken
    pos := pos * 8;                   // pos*8(bit) ergibt das gesuchte Byte
    inc(inAddr,count shl pos);        // addieren und dabei den Offset in Byte schieben
   Originalbyte := (inAddr_bkup and ($FF shl (pos)) shr (pos)); // Wert des Originalbyte bestimmen    
    Originalbyte := (inAddr and ($FF shl (pos)) shr (pos));     // Wert des Bytes mit Offset bestimmen     
    if Offsetbyte = Originalbyte + count then   // Wenn Offsetbyte = Originalbyte+Offset 
      result := inet_ntoa(in_Addr(inAddr))      // zurückwandeln
    else showmessage('Offset zu groß')          // sonst Fehlermeldung
end;

Ist aber bestimmt nicht so gelöst wie du das dachtest, oder?

[sirius]

Ich hatte nicht so weit gedacht. Aber sieht doch gut aus.

Ich hätte wahrscheinlich vorm Addieren überprüft. Es gibt Dutzende Wege hier. Und solange das Ergebnis stimmt.....