Rechnen mit IP-Adressen

Validierung, Umwandlung, Masken, ...

IP-Adressen spielen in der Informatik eine häufige und wichtige Rolle. Es handelt sich zwar um relativ einfache Zahlen von 32 (IPv4) oder 128 (IPv6) Bit Länge, die besondere Schreibweise bedingt jedoch einige spezielle Aufgaben. Auf dieser Seite werden einige Beispiele für den Umgang mit IP-Adressen vorgestellt.
Da in der Praxis IPv4 und PHP dominieren, wird diese IP-Version und Programmiersprache bevorzugt.
Algorithmen Ausgewählte IT-Rezepte
Internet Protocol Komprimierte Stichworte zum IP-Protokoll
IPv4 → Dezimalzahl Umwandlung eines IPv4-Strings in eine ganze Dezimalzahl
Dezimalzahl → IPv4 Umwandlung einer Dezimalzahl in einen IPv4-String
Validierung Sind die Daten brauchbare IPv4-Adressen ?
Maske Definiert den Adressen-Bereich des eigenen Netzwerks (LAN)
BitLevel Unterscheidung von lokalen und entfernten Adressen

Internet Protocol IPv4

Internet Protocol IP

Jedes an ein → Netzwerk angeschlossene Gerät (PC, Drucker, ...) muss an einer eindeutigen Adresse erreichbar sein. Die Adressen sind nach dem → Internet Protocol organisiert, meist in seiner klassischen Form als IPv4 (Version 4), derzeit noch selten in der neuen Version 6.

Wert und Darstellung

Eine IPv4-Adresse entspricht intern einer positiven ganzen Zahl von 32 Bit. Für den praktischen Gebrauch stellt man je 8 Bit als Dezimalzahl 0..255 dar.
Eine typische IPv4-Adresse (Ihre Client-IP-Adresse) wird meistens so formuliert:
38.107.179.211

♦ Details zu allen angeführten Stichworten im Kapitel Netzwerk dieses Webs.

Eindeutigkeit

Die IP-Adressen sind meist nur innerhalb des eigenen Netzwerks (LAN) eindeutig. Nach außen (globales Internet) wird das gesamte lokale Netzwerk (LAN) durch eine einzige - global eindeutige - IP-Adresse des verwendeten → Routers (Proxy-Servers) vertreten.
Wenn sich ihr PC in einem LAN befindet, dann ist die links angegebene Client-Adresse jene ihres Routers.

Fixe und variable IP-Adressen

Die IP-Adressen von gemeinsam genutzten Geräten (Server, Router, Drucker, ...) müssen fix eingestellt sein, jene der angeschlossenen Client-PC werden optional von einem → DHCP-Server nach Bedarf zugeteilt.

Domain Namen

IP-Adressen sind für Menschen unhandlich. Man benutzt als Synonyme Domain-Namen, die von einem eigenen Internet-Dienst (→ DNS) in IP-Adressen übersetzt werden.

IPv4 -> Dezimalzahl
• Vor Verwendung eines Strings sollten sie prüfen, ob er brauchbar ist (↓ Validierung).

• Zur Umwandlung eines IPv4-Strings in eine ganze Zahl spaltet man den String an den . Punkten und wandelt die erhaltenen 4 Teil-Strings in je eine ganze Zahl 0..255 um.
Die Zahlen werden entsprechend ihrer Stellenwerte im 256er-System zusammengesetzt.
Man vermeidet besser Funktionen zur Potenzierung und erreicht das gleiche Ziel mit einfachen Multiplikationen.

• Anwendung: Ganze Dezimalzahlen (long [unsigned] integer) sind zur ↓ numerischen Verarbeitung und zum Speichern (in einer Datenbank) viel besser geeignet als Strings.

♦ Details zur Spaltung von Strings mit PHP, zu Regulären Ausdrücken (RegExp) 		Beispiel: PHP-Funktion ip4_to_int()
function ip4_to_int($ip4) {
$ip4a = preg_split("/\./",$ip4);
$ip4int = 0;
foreach($ip4a as $k) {
$ip4int = $ip4int * 256 + $k;
}
return $ip4int;
}

Live-Beispiel

Die 4 Teilstrings stellen die Ziffern einer Zahl im 256er-System dar. Damit man für diese Ziffern nicht 256 verschiedene Zeichen verwenden muss, wird jede der 'Ziffern' durch eine Dezimalzahl dargestellt. Jede Zahl eines Stellenwert-Systems wird aus den Stellenwerten * Werten der einzelnen Ziffern zusammengesetzt.

Das Beispiel rechts wurde mit PHP Live berechnet.
Die Hexadezimalzahl wurde mit → Funktion printf("0x%08X",$ip) ausgegeben.

♦ Details zu Zahlen und Zahlensystemen in der Informatik 		IPv4 Adresse als String: 38.107.179.211
Umwandlung in eine ganze Zahl (dezimal, zuletzt hexadezimal):
ip4_to_int('38.107.179.211') =
256^3*38 + 256^2*107 + 256^1*179 + 256^0*211 =
16777216*38 + 65536*107 + 256*179 + 1*211 =
637534208 + 7012352 + 45824 + 211 =
644592595
= 0x266BB3D3

Dezimalzahl -> Ipv4
• Vor Verwendung einer (IP)-Dezimalzahl sollten sie prüfen, ob sie brauchbar ist (↓ Validierung).
• Zur Umwandlung einer Zahl in einen IPv4-String muss man die Werte der 4 anzugebenden Stellen im 256er-Zahlensystem berechnen.
Die Stellenwerte in diesem System betragen (von rechts nach links) 256^0=1, 256^1=256, 256^2=65536, 256^3=16777216

• Die Funktion erwartet als Argument eine positive ganze Zahl mit der Bedeutung einer 32-Bit IP-Adresse.
• Der IPv4-String wird in der Variablen $ip4 zusammengesetzt und zurückgegeben.

• Es ihat Vorteile, zuerst mit der schnellen → Modulo-(Rest)-Funktion (hier: Modulo-Operator %) den Rest zu berechnen. In diesem Fall ist das Ergebnis der folgenden Division (Berechnung einer Stelle $i) immer ganzzahlig: Wenn verfügbar, kann man dazu eine schnelle Ganzzahlen-Division verwenden.
Die weiteren Schritte entsprechen der üblichen menschlichen Vorgangsweise (nächster ↓ Absatz).

Das Beispiel rechts wurde Live mit PHP berechnet. 		Beispiel: PHP-Funktion int_to_ip4()
function int_to_ip4($intip4) {
$div = 256*256*256;
$ip4 = '';
while($div>=1) {
if(strlen($ip4)) {$ip4 .= '.';}
$rest = $intip4 % $div;
$intip4 -= $rest;
$i = $intip4 / $div;
$intip4 = $rest;
$ip4 .= $i;
$div /= 256;
}
return $ip4;
}

Live-Beispiel

Die Berechnung wurde zum besseren Verständnis etwas umgestellt, so wie die meisten Menschen rechnen würden. In dieser Form kann man es u.a. mit jedem Kalkulations-Programm (MS-Excel, OpenOffice-Calc, ...) nachrechnen:

• Der Stellenwert $div im 256er-System wird berechnet.
• Der Rest $rest wird durch den Stellenwert dividiert. Das Ergebnis wird mit Funktionen wie floor(), int() abgeschnitten und ergibt die Stelle $i
• Der neue Rest $rest ergibt sich aus der Differenz zwischen dem alten $rest und dem Wert der Stelle $div*$i oder alternativ mit Modulo-Funktion oder Modulo-Operator aus $rest % $div

• Danach berechnet man den nächsten Stellenwert $div=$div/256 und nach dem gleichen Verfahren in einer Schleife die weiteren Stellen.

• Alle 4 berechneten Stellen werden mit . Punkt-Zeichen zu einem IPv4-String verknüpft.
Dezimalzahl:   $rest = 644592595

Stellenwert(3): $div = 16777216
Stelle(3): $i = floor(644592595/16777216) = 38
Rest: $rest = 644592595 % 16777216 = 7058387

Stellenwert(2): $div = 65536
Stelle(2): $i = floor(7058387/65536) = 107
Rest: $rest = 7058387 % 65536 = 46035

Stellenwert(1): $div = 256
Stelle(1): $i = floor(46035/256) = 179
Rest: $rest = 46035 % 256 = 211

Stellenwert(0): $div = 1
Stelle(0): $i = floor(211/1) = 211
Rest: $rest = 211 % 1 = 0

Ergebnis: 38.107.179.211

Validierung einer IPv4-Adresse
Bevor man eine IP-Adresse verwendet, sollte man feststellen, ob die Daten (String oder Dezimalzahl) überhaupt brauchbar sind.
In der Praxis kommt man meist erst dann auf diese Idee, wenn ein Programm nicht funktioniert. 		Deshalb befindet sich dieses Kapitel nicht am Beginn der Webseite, wo es zwar hingehört, jedoch meist unbeachtet bleibt. Nehmen sie die Beispiele als Anregungen, um eigene Funktionen gegen fehlerhafte (Eingabe)-Daten abzusichern.

Einfacher Test

Vorgabe ist ein String $s mit einer vermutlich darin enthaltenen IPv4-Adresse.
• Der Test wird mit einem → Regulären Ausdruck (RegExp) durchgeführt, welcher die gefundene Adresse zurückgibt (wird an die Variable $ip zugewiesen).
• Jede der 4 Zahlen (\d) muss mindestens 1 Dezimalstelle haben.
• Wenn eine Programmiersprache den Code \d nicht versteht, dann kann man an seiner Stelle [0-9]{1,3} verwenden. Mit der Begrenzung in {} werden nur Dezimalzahlen mit 1..3 Stellen erlaubt.
Ergebnis des Demo-Beispiels: Die Adresse wird nur dann ausgegeben, wenn der Test erfolgreich war. 		Beispiel mit Perl:
$s = 'abc 38.107.179.211 xyz';
if($s=~m/(\d+\.\d+\.\d+\.\d+)/) {
$ip = $1;
print "Adresse = $ip \n";
}
else{...}
Beispiel mit PHP:
if(preg_match("/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/",$s,$ra)) {
$ip = $ra[1];
print "Adresse = $ip \n";
}
else{...}

Port

In dieser Variante wird optional ein nachgestellter → Port berücksichtigt, falls angegeben. 		Perl-Beispiel: Isolierung von IPv4-Adresse und Port
$s = 'abc 38.107.179.211:57621 xyz';
if($s=~m/(\d+\.\d+\.\d+\.\d+:?\d*)/) {...}

Besserer Test

• Die Beispiel-Funktion ip4_test() erwartet als Argument einen String $s mit IPv4-Adresse und optional mit einem Port.
• Rückgabe: Die Funktion gibt bei korrekten Daten ein Array von 6 Elementen zurück:
[0]...[3] -> IP-Ziffern (0..255)
[4] -> Port (0..65535) oder -1
[5] -> Adresse als Dezimalzahl
• Bei einem Fehler gibt die Funktion den Wert Null zurück.

► Initialisierung: Die Variable $ok erhält die Ergebnisse der Tests. Das Array $ipa dient zur Rückgabe der Daten und wird mit =-1 initialisiert.

► Test und Isolierung: Der übergebene String wird mit einem RegExp getestet. Bei einem Treffer wird der isolierte IPv4-String an die Variable $s zugewiesen, und die weiteren Arbeiten ausgeführt. Bei negativem Test bleibt $ok=0 und die Funktion gibt ihren Fehler-Wert zurück.

► Port: Der String $s wird mit einem RegExp getestet. Bei einem Treffer wird der String $s verkürzt und die PortNummer in $j getestet. Nur eine gültige PortNummer wird an das Ergebnis-Element $ipa[4] zugewiesen.

► IPv4-Ziffern: Der String $s wird an den . Punkt-Zeichen aufgespalten. Weitere Arbeiten werden nur dann ausgeführt, wenn das Ergebnis-Array $ipb genau 4 Elemente hat:
In diesem Fall wird jedes einzelne Element in der Variablen $j getestet. Nur wenn alle 4 Elemente im Bereich 0..255 liegen, bleibt das Test-Erbenis $ok>0.

► Dezimalzahl: Zuletzt wird der Zahlenwert der gültigen IP-Adresse berechnet und an das Ergebnis-Element $ipa[5] zugewiesen.

► Rückgabe: Für zulässige IPv4-Adressen wird das Array $ipa zurückgegeben, ansonsten der Fehler-Wert Null.

● Anwendung: Das Beispiel gibt in diesem Fall 6 Zahlen aus:
Zuerst die isolierten Zahlenwerte der 4 IP-Ziffern
Danach die Port-Nummer
Zuletzt die IP-Adresse als 32-Bit Dezimalzahl. 		Diese PHP-Funktion isoliert und validiert eine IP-Adresse und gibt die Ergebnisse als → Array zurück:
function ip4_test($s) {
$ok=0; $ipa=array();
for($i=0;$i<6;$i++) {$ipa[$i]=-1;}
// Test + Isolierung
if(preg_match("/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:?\d{1,5})/",$s,$ra)) {
$s = $ra[1];
// Port
if(preg_match("/^([^:]*):(.*)$/",$s,$ra)) {
$s = $ra[1];
$j = $ra[2] + 0;
if($i>=0 && $i<65536) {$ipa[4] = $j;}
}
// IPv4-Ziffern 0..3
$ipb=preg_split("/\./",$s);
if(count($ipb)==4) {
$ok = 1;
for($i=0;$i<4;$i++) {
$j = $ipb[$i] + 0;
if($j>=0 && $j<256) {$ipa[$i] = $j;}
else{$ok = 0;}
}
}
// Dezimalzahl
if($ok) {
$j = 0;
for($i=0;$i<4;$i++) {
$j = $j * 256 + $ipa[$i];
}
$ipa[5] = $j;
}
}
// Rueckgabe
if($ok) {return $ipa;}
else{return Null;}
}
Anwendung:
$s = 'abc 38.107.179.211:57621 xyz';
$ipa = ip4_test($s);
if($ipa) {
foreach($ipa as $x) {print ' '.$x;}
}
else{...}
Ergebnis:
$ipa = 38 107 179 211 57621 644592595

Reihenfolge

Die Elemente [0]..[3] des Ergebnis-Arrays enthalten die Zahlenwerte der einzelnen IPv4-Ziffern. Im Beispiel sind die Ziffern in der gelesenen Reihenfolge (von links nach rechts) eingetragen.
• Die Logik fordert allerdings genau die umgekehrte Reihenfolge, nämlich die niedrigst-wertige IP-Ziffer im Element [0] usw.
Wenn sie die logische Reihenfolge bevorzugen, dann müssen sie die Funktion geringfügig ändern.

Einschränkungen

Die Sicherheit ihrer Programme nimmt zu, wenn sie die Tests (u.a. der Funktion ip4_test() strenger formulieren können.

► Je nach Anwendung kann man z.B. die erlaubten → Port-Nummern auf Well-Known Ports (Standard-Server 0..1023), Registered Ports (1024..49151) und/oder Private Ports (49152..65535) begrenzen.

► Im eigenen lokalen Netzwerk (LAN) ist der Bereich erlaubter Adressen begrenzt und genau bekannt, z.B. 192.168.12.0 bis 192.168.12.255
Wenn das zutrifft, dann kann man auch den Adressen-Test wesentlich strenger und damit sicherer formulieren.

Maske

Maske

Eine → Maske dient als Werkzeug, mit dem festgestellt wird, ob sich eine IP-Adresse in einem bestimmten Bereich befindet.
Meistens ist der 'Bereich' das eigene lokale Netzwerk (LAN). Die Maske dient in diesem Fall der Unterscheidung, ob eine IP-Adresse im eigenen LAN liegt (und daher direkt erreichbar ist) oder außerhalb (über den → Router / Proxy-Server).
In diesem Kapitel werden Beispiele vorgestellt, mit denen man eine Maske in einem String erkennen und sie daraus isolieren kann.

Klassische Form

Masken werden meist in der gleichen Form wie IPv4-Adressen angegeben, z.B. (typisch)
255.255.255.0
Diese Form wird entweder alleinstehend angegeben, oder nach einer IPv4-Adresse und durch ein Leerzeichen getrennt:
192.168.12.34 255.255.255.0
Alle praktisch verwendeten Masken beginnen mit der Zahl 255

Die Beispiel-Funktion testet den String $s mit einem RegExp und gibt ein → Array $ipma mit 2 Elementen zurück:

Eine gefundene IPv4-Adresse wird als String in das Element $ipma[0] des Rückgabe-Arrays eingetragen. Danch wird der isolierte Rest $ra[2] mit einem weiteren RegExp getestet: Wenn eine Maske vorliegt, dann wird sie als String in das Element $ipma[1] eingetragen.
♣ Tipp: Für die praktische Anwendung sollten sie noch Tests zur Validierung ergänzen.

Mit einer Funktion wie ip4_to_int() (auf dieser Seite oben) kann man eine Maske dieser Form anschließend in eine Dezimalzahl umwandeln.
Beispiel: PHP-Funktion zur Isolierung von IP-Adresse und (optional) einer 'klassischen' Maske:
function ip4_mask($s) {
$ipma = array('','');
if(preg_match("/(\d+\.\d+\.\d+\.\d+)(.*)/",$s,$ra)) {
if($ra[1]) {$ipma[0] = $ra[1];}
if($ra[2]) {
$t = $ra[2];
if(preg_match("/ (255\.\d+\.\d+\.\d+)/",$t,$ra)) {
$ipma[1] = $ra[1];
}
}
}
return $ipma
}
Anwendung:
$s = '192.168.12.34 255.255.255.0';
$ipma = ip4_mask($s);
print 'IP-Adresse = '.$ipma[0]."\n";
print 'Maske = '.$ipma[1]."\n";
Ergebnis:
IP-Adresse = 192.168.12.34
Maske = 255.255.255.0

CIDR

Die moderne → CIDR-Formulierung einer Maske gibt die Anzahl übereinstimmender Bits (von links nach rechts, d.h,. von der höchstwertigen MSB Bits zu den niedrigstwertigen LSB Bits) an.

Diese Zahl (in der Praxis fast nur die Werte 8, 16, 24) wird von einer vorangehenden IP-Adresse durch einen / Schrägstrich getrennt, z.B.
192.168.12.34/24

Die Beispiel-Funktion testet den String $s mit einem RegExp und gibt ein → Array $ipca mit 2 Elementen zurück:

Eine gefundene IPv4-Adresse wird als String in das Element [0] des Arrays eingetragen, eine CIDR-Maske als ganze Zahl 0..32 in das Element [1]
♣ Tipp: Für die praktische Anwendung sollten sie noch Tests zur Validierung ergänzen.
Berispiel: PHP-Funktion zur Isolierung von IP-Adresse und CIDR-Maske
function ip4_cidr($s) {
$ipca = array('',0);
if(preg_match("/(\d+\.\d+\.\d+\.\d+)\/?(\d+)/",$s,$ra)) {
if($ra[1]) {$ipca[0] = $ra[1];}
if($ra[2]) {$ipca[1] = $ra[2];}
}
return $ipca;
}
Anwendung:
$s = '192.168.12.34/24';
$ipca = ip4_cidr($s);
print 'IP-Adresse = '.$ipca[0]."\n";
print 'CIDR-Nr = '.$ipca[1]."\n";
Ergebnis:
IP-Adresse = 192.168.12.34
CIDR-Nr = 24

Umwandlung CIDR -> Dezimalzahl

Zur praktischen Anwendung ist es manchmal sinnvoll, eine CIDR-Maske in eine 32-Bit Dezimalzahl umzuwandeln.

Die Beispiel-Funktion cidr_to_number erwartet eine Zahl 0..32 als Argument. Daraus wird ein Bit-Muster $f1 berechnet:
f1 = 2^cidr - 1
Das Muster wird durch Multiplikation nach links verschoben, bis sein höchstes Bit gleichzeitig das höchstwertige MSB Bit der Maske ist:
f2 = 2^(32-cidr)

Aus der berechneten Dezimalzahl $cidnr kann man u.a. mit Funktion int_to_ip4() (auf dieser Seite) einen String der 'klassischen' Maske erzeugen. Die hexadezimale Darstellung mit → Funktion printf() lässt die Struktur der Maske besser erkennen.

♣ Tipp: Wenn eine Programmiersprache über → Bit-Level Funktionen verfügt, dann kann man diese Funktion wesentlich vereinfachen. 		PHP-Funktion berechnet Maske als Dezimalzahl aus der CIDR-BitAnzahl:
function cidr_to_number($cidr) {
$f1 = pow(2,$cidr)-1;
$f2 = pow(2,32-$cidr);
$cidnr = $f1 * $f2;
return $cidnr;
}
Anwendung:
$cidr = 24;
$n = cidr_to_number($cidr);
print "cidr_to_number($cidnr) = $n ";
printf("= 0x%08X \n",$n);
$t = int_to_ip4($n);
print "int_to_ip4($n) = '$t' \n";
Ergebnis:
cidr_to_number(24) = 4294967040 = 0xFFFFFF00
int_to_ip4(4294967040) = '255.255.255.0'

BitLevel Operationen
Der Zweck einer Maske ist die Feststellung, ob eine zu testende IP-Adresse in einem definierten Bereich (normalerweise: im eigenen LAN) liegt. Dazu werden typisch einige Operationen auf → Bit-Level ausgeführt. Diese lassen sich besonders schnell - auch von Hardware Schalt-Elementen - ausführen.

Basis-Adresse

Jedes lokale Netzwerk (LAN) ist durch eine eindeutige Basis-Adresse bezeichnet.
• Man erhält sie durch AND-Verknüpfung einer beliebigen Geräte-Adresse (= des eigenen PC) mit der Maske.

• Das Ergebnis enthält alle signifikaten Bits des LAN.

• Jene Bits, durch welche sich die individuellen Adressen der einzelnen Geräte unterscheiden, werden dabei =0 gesetzt (don't care).
Beispiel:
Adresse des eigenen PC 1921681234
1100000010101000 0000110000100010
Maske 2552552550
1111111111111111 1111111100000000
AND 1100000010101000 0000110000000000
 signifikant don't care

Test-Adresse

• Die zu testende Adresse wird ebenfalls mit der Maske AND-verknüpft.

• Ergebnis: Wenn die Test-Adresse im gleichen LAN liegt, dann sollte ihr signifikanter Teil identisch mit jenem der Basis-Adresse sein. 		Beispiel:
Test-Adresse 1921681256
1100000010101000 0000110000111000
Maske 2552552550
1111111111111111 1111111100000000
AND 1100000010101000 0000110000000000
 signifikant don't care

Vergleich

Die logische Funktion (Operator) XOR eignet sich gut zum Vergleich von 2 BitMustern.
• Eines der Muster (die Basis-Adresse) wird invertiert und danach mit dem anderen Muster XOR-verknüpft.

• Ergebnis: Wenn die Test-Adresse im LAN liegt, dann sind alle 32 Bits des Ergebnisses =1
• Wenn mindestens 1 Bit =0 ist, dann liegt die Test-Adresse nicht im LAN.
Beispiel:
Basis 1100000010101000 0000110000000000
NOT 0011111101010111 1111001111111111
Test 1100000010101000 0000000000000000
XOR 1111111111111111 1111111111111111

LAN-Test

Die Funktion führt die gleichen Operationen durch wie am Beispiel oben demonstriert.Sie ist relativ umständlich programmiert, damit sie bei Bedarf jede einzelne Operation dokumentieren können.

32-Bit-Begrenzung
Die meisten Programmiersprachen neigen dazu, Variable mit einem höchstwertigen Bit MSB=1 als negative Zahlen zu interpretieren und unkontrolliert weitere führende 1-Bits einzufügen. Deshalb wird zur Sicherheit das Ergebnis jeder Operation durch AND-Verknüpfung auf 32-Bit begrenzt.

Basis-Adresse
Die erste Adresse $ipa wird mit der Maske $msk AND-verknüpft (Operator &), das Ergebnis $ipam wird invertiert (Operator ~) und ergibt $ipamq

Test-Adresse
Die zweite Adresse $ipb wird ebenfalls mit der Maske $msk AND-verknüpft und ergibt $ipbm

Vergleich
Die beiden Variablen $ipamq und $ipbm werden XOR-verknüpft (Operator ^), das Ergebnis wird in $xab abgelegt.

Ergebnis
Wenn die beiden Adressen $ipa, $ipb im gleichen LAN-Bereich liegen, dann besteht $xab ausschließlich aus 1-Bits, und die Funktion gibt =1 zurück.
In jedem anderen Fall gibt die Funktion =0 zurück. 		PHP-Funktion prüft, ob eine IP-Adresse im eigenen Netzwerk liegt:
function bitlevel_test($ipa,$ipb,$msk) {
// Basis-Adresse
$ipam = $ipa & $msk;
$ipam = $ipam & 0xFFFFFFFF;
$ipamq = ~$ipam;
$ipamq = $ipamq & 0xFFFFFFFF;
// Test-Adresse
$ipbm = $ipb & $msk;
$ipbm = $ipbm & 0xFFFFFFFF;
// Vergleich
$xab = $ipamq ^ $ipbm;
$xab = $xab & 0xFFFFFFFF;
// Ergebnis
if($xab==0xFFFFFFFF) {return 1;}
else{return 0;}
}
Anwendung:
$my_adr = '192.168.12.34';
$my_msk = '255.255.255.0';
$xx_adr = '192.168.12.56';
$ok = bitlevel_test($my_adr,$xx_adr,$my_msk);
print "Bitlevel-Test($xx_adr) = $ok \n";
$xx_adr = '192.168.13.56';
$ok = bitlevel_test($my_adr,$xx_adr,$my_msk);
print "Bitlevel-Test($xx_adr) = $ok \n";
Ergebnis:
BitLevel-Test(192.168.12.56) = 1
BitLevel-Test(192.168.13.56) = 0

Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Algorithmen   | IPv4
Letzte Änderung dieser Seite: 2011-11-30 12:19:32