Navigation
 Startseite
 Fachbücher
 Anzeigenmarkt
 Forum
 Webmaster News
 Script Newsletter
 Push Meldungen
 Kontakt
 Script Installation
 Php
 Php Tutorials
 Lernpfade
 Webhoster Vergleich
 Impressum

Community-Bereich
 kostenlos Registrieren
 Anmelden
 Benutzerliste

Script Datenbank
 Script Archiv
 Script Top 20
 Screenshots
 Testberichte

Suche
 

Unsere Php Scripts
 Counter Script
 Umfrage Script
 Bilder Upload Script
 Terminverwaltung
 Simple PHP Forum
 RSS Grabber

Tools und Generatoren
 .htpasswd Generator
 md5 Generator
 base64 Generator
 Markdown to HTML
 Colorpicker
 Unix timestamp Tool
 Unit Test Generator
 TLD Liste
 Webkatalog‑Verzeichnis

Webspace-Mieten.d...
Webhosting mit Plesk aus Erfurt: Vier...
https://www.Webspace-Mieten.de
Artfiles.de
Bietet Serviceorientierte...
https://www.Artfiles.de
 
 
 

PHP inet_pton() Function: IPv4 und IPv6 binär speichern

Sie befinden sich: Home > Php Tutorial > PHP inet_pton() Function: I...

PHP inet_pton() Function: IPv4 und IPv6 binär speichern
Veröffentlicht am:
22.11.2026
Hits / Besucher:
10
Sprache:
  Deutsch
Tutorial Art:
eigenes
Merkliste:
 
Beschreibung

Der Login-Schutz soll ganze Netze sperren, aber die Besucher kommen mal über IPv4 und mal über IPv6, und ip2long() liefert bei der Hälfte nur false. Wie eine IPv4-Adresse zur Zahl wird und wie man damit in einem reinen IPv4-Netz rechnet, zeigt das Tutorial zu ip2long(). Hier geht es um den Fall, dass beide Protokolle zusammenkommen: 4 und 16 Byte in einer Spalte, IPv4-Adressen in IPv6-Schreibweise und Netzprüfungen, die für beide funktionieren. PHP inet_pton() ist dafür das Werkzeug, solange man weiß, wo es still das Falsche liefert.

Illustration zum Tutorial: PHP inet_pton() Function: IPv4 und IPv6 binär speichern

Gemessen wurde für dieses Tutorial gegen MySQL 8.0 und mit PHP 8.1 bis 8.5. Zwischen den PHP-Versionen gab es dabei keine Unterschiede.

Was PHP inet_pton() aus einer Adresse macht

PHP inet_pton() nimmt eine lesbare IP-Adresse entgegen und gibt ihre Binärdarstellung zurück, also genau die Bytes, mit denen das Netzwerk arbeitet. Eine IPv4-Adresse ergibt 4 Byte, das sind 32 Bit. Eine IPv6-Adresse ergibt 16 Byte, also 128 Bit. Das Ergebnis ist ein String, aber kein Text: Wer ihn mit echo ausgibt, sieht Zeichensalat. Zum Anschauen dient bin2hex(), zurück in die lesbare Form führt inet_ntop().

<?php

$v4 = inet_pton('192.0.2.1');
$v6 = inet_pton('2001:db8::1');
echo strlen($v4), ' ', bin2hex($v4), PHP_EOL;
/* 4 c0000201 */
echo strlen($v6), ' ', bin2hex($v6), PHP_EOL;
/* 16 20010db8000000000000000000000001 */
echo inet_ntop($v6), PHP_EOL;
/* 2001:db8::1 */

Für IPv4 sind die 4 Byte dieselbe Zahl, die ip2long() liefert, nur anders verpackt. unpack('N', inet_pton('192.168.1.1'))[1] ergab im Test 3232235777, genau wie ip2long('192.168.1.1'). Der Unterschied liegt darin, dass PHP inet_pton() auch mit 16 Byte umgehen kann. Das Diagramm zeigt den Weg, den eine Adresse in diesem Tutorial nimmt, vom Text bis zum Vergleich mit einem Netz:

flowchart TD
    A[Adresse als Text] --> B[Beiwerk entfernen]
    B --> C{inet_pton}
    C -->|false| D[ablehnen]
    C -->|4 Byte| E[IPv4]
    C -->|16 Byte| F{IPv4-mapped?}
    F -->|ja| E
    F -->|nein| G[IPv6]
    E --> H[Maske anwenden]
    G --> H
    H --> I[mit Netz vergleichen]

Die Abschnitte unten gehen diesen Weg Schritt für Schritt durch, vom Beiwerk bis zur Maske.

Die Signatur im Original: Rückgabewert string oder false

inet_pton(string $ip): string|false


/* ip - a human readable IPv4 or IPv6
address, e.g. 192.0.2.1 or 2001:db8::1
return - the packed in_addr representation:
a binary string of 4 bytes (32bit)
or 16 bytes (128bit), or false if
the address is not valid
This function converts a human readable
IP address into its packed binary form.
inet_ntop() converts it back. Both work
for IPv4 and IPv6 addresses. */

Wichtig ist das false. Bei einer ungültigen Adresse gibt PHP inet_pton() nur diesen Wert zurück, ohne Warnung und ohne Notice, auch mit error_reporting(-1). Das war in PHP 8.1, 8.2, 8.3, 8.4 und 8.5 gleich, unter Windows wie unter Linux. Einzige Meldungen gibt es bei falschen Typen: null erzeugt Deprecated: inet_pton(): Passing null to parameter #1 ($ip) of type string is deprecated, ein Array einen TypeError. inet_ntop() arbeitet genauso still und liefert false für alles, was nicht genau 4 oder 16 Byte lang ist.

Warum PHP inet_pton() false liefert, ohne zu warnen

Die Funktion ist streng. Sie erwartet genau eine Adresse in Normschreibweise und sonst nichts. Die folgende Tabelle zeigt, was im Test abgelehnt wurde, und gilt unter Windows wie unter Linux:

Eingabe Ergebnis Grund
192.168.001.001, 010.1.1.1 false führende Nullen
" 1.2.3.4", "1.2.3.4\n" false Leerzeichen oder Zeilenumbruch
1.2.3.4:80, [::1]:443 false Port und Klammern
fe80::1%eth0 false Zonen-ID der Schnittstelle
192.168.1.0/24 false Präfixlänge
127.1, 0x7f.0.0.1, localhost false Kurzform, Hex, Hostname
2001:db8::00001 false fünf Hexziffern
2001:DB8:0:0:0:0:0:1 16 Byte Großbuchstaben und Nullen sind erlaubt
::192.0.2.1 16 Byte alte IPv4-compatible-Form, angenommen

Am häufigsten trifft es Altdaten. Eine Sperrliste aus einem Forum oder ein Export aus einer Tabellenkalkulation füllt Adressen gern auf drei Stellen auf, und dann wirkt die halbe Liste nicht. filter_var() mit FILTER_VALIDATE_IP lehnt dieselben Schreibweisen ab. Wie die Filterfamilie arbeitet, steht im Tutorial zu FILTER_VALIDATE_IP und filter_validate_email. Gefährlich ist, dass MySQL anders denkt. INET6_ATON('192.168.001.001') ergab im Test ohne Fehler C0A80101, also 192.168.1.1, und INET_ATON('010.001.002.003') las die Nullen dezimal. Datenbank und PHP sind sich bei denselben Daten also uneinig.

Altdaten repariert man einmal beim Import, nicht bei jedem Aufruf. Die Funktion prüft das Muster aus vier Zahlengruppen, entfernt die führenden Nullen und lässt PHP inet_pton() das Ergebnis bestätigen:

<?php

function ipv4_reparieren(string $ip): string|false
{
$muster = '/^\d{1,3}(\.\d{1,3}){3}$/';
if (!preg_match($muster, $ip)) {
return false;
}
$teile = array_map('intval', explode('.', $ip));
$neu = implode('.', $teile);
return inet_pton($neu) === false ? false : $neu;
}

var_dump(ipv4_reparieren('192.168.001.001'));
/* string(11) "192.168.1.1" */
var_dump(ipv4_reparieren('010.001.002.003'));
/* string(8) "10.1.2.3" */
var_dump(ipv4_reparieren('256.001.1.1'));
/* bool(false) */

Die Zahlen werden dabei dezimal gelesen. Die alte C-Funktion inet_aton() hätte 010 als Oktalzahl 8 verstanden, genau deshalb verbietet die strenge Schreibweise führende Nullen. Wer eine Liste importiert, protokolliert jede abgelehnte Zeile, statt ein false still zu überspringen.

IPv4 in IPv6-Schreibweise: das ::ffff:-Problem

Ein Shop sperrt Konten nach zu vielen Fehlversuchen über die IP-Adresse. Seit dem Umzug in einen Container greift die Sperre bei IPv4-Kunden nicht mehr, und im Log stehen Adressen wie ::ffff:203.0.113.9. Das ist kein Fehler im Code, sondern eine Eigenschaft des Servers. Ein Webserver, der unter Linux auf [::] lauscht, nimmt beide Protokolle an und meldet IPv4-Clients in IPv6-Schreibweise. Im Test lieferte ein PHP-Server auf [::] für einen Aufruf über 127.0.0.1 den Wert ::ffff:127.0.0.1 in $_SERVER['REMOTE_ADDR']. Unter Windows nahm derselbe Server IPv4 gar nicht an, die Verbindung wurde verweigert.

Für PHP inet_pton() sind das zwei völlig verschiedene Werte. inet_pton('::ffff:192.0.2.1') ergibt 16 Byte, inet_pton('192.0.2.1') nur 4, und der Vergleich mit === ist false. Die Lösung ist eine Normalform: Beginnen die 16 Byte mit zehn Nullbytes und zwei Bytes 0xff, steht in den letzten vier Byte die IPv4-Adresse.

<?php

function ip_normal(string $ip): string|false
{
$bin = inet_pton($ip);
if ($bin === false) {
return false;
}
$mapped = str_repeat(chr(0), 10)
. str_repeat(chr(255), 2);
if (strlen($bin) === 16
&& str_starts_with($bin, $mapped)) {
return substr($bin, 12);
}
return $bin;
}

var_dump(
ip_normal('::ffff:203.0.113.9')
=== ip_normal('203.0.113.9')
);
/* bool(true) */

chr(0) und chr(255) statt Escape-Sequenzen halten den Code lesbar. Die veraltete Form ::192.0.2.1 wandelt die Funktion bewusst nicht um. PHP inet_pton() nimmt sie zwar an, aber kein aktueller Server erzeugt sie noch. Gespeichert und verglichen wird ab jetzt nur, was durch ip_normal() gegangen ist.

Adressen aus Proxy-Headern bereinigen

Hinter einem Load Balancer kommt die echte Adresse aus einem Header wie X-Forwarded-For, und dort steht nicht immer eine saubere Adresse. Je nach Weg kommen [2001:db8::1]:443, 1.2.3.4:80, ein Link-Local-Wert wie fe80::1%eth0 oder eine ganze Kette 203.0.113.7, 198.51.100.2, 10.0.0.2. PHP inet_pton() lehnt alle diese Formen ab. Fehlt der Header, wird es noch unangenehmer: inet_pton($_SERVER['HTTP_X_FORWARDED_FOR'] ?? null) erzeugt die Deprecation zu null.

Die Funktion unten nimmt das Beiwerk ab. Eckige Klammern mit Port werden ausgepackt, ein Port hinter IPv4 abgetrennt und die Zonen-ID hinter dem Prozentzeichen verworfen, denn sie bezeichnet die Netzwerkschnittstelle des Rechners und gehört nicht zur Adresse:

<?php

function ip_aus_text(string $roh): string|false
{
$ip = trim($roh);
$klammer = '/^\[([^\]]+)\](:\d+)?$/';
if (preg_match($klammer, $ip, $t)) {
$ip = $t[1];
} elseif (substr_count($ip, ':') === 1) {
$ip = strstr($ip, ':', true);
}
$ip = explode('%', $ip, 2)[0];
return inet_pton($ip) === false ? false : $ip;
}

var_dump(ip_aus_text('[2001:db8::1]:443'));
/* string(11) "2001:db8::1" */
var_dump(ip_aus_text('fe80::1%eth0'));
/* string(7) "fe80::1" */
var_dump(ip_aus_text(' 1.2.3.4:80 '));
/* string(7) "1.2.3.4" */

Bei einer Kette nimmt man nicht die erste Adresse, sondern den Eintrag, den der eigene Proxy angehängt hat, meist den letzten. explode() am Komma und end() lieferten im Test " 10.0.0.2" mit führendem Leerzeichen, und daran scheitert PHP inet_pton(). Erst trim() oder ip_aus_text() macht daraus 10.0.0.2. Alles links davon hat der Client selbst geschickt und kann frei erfunden sein. Wie man die Besucheradresse überhaupt ausliest, zeigt das Tutorial zu IP-Adresse, Host und Referer.

Rohbytes nie nach außen geben

Eine Schnittstelle schickt Login-Ereignisse als JSON an ein Monitoring, mit der Binärform der Adresse im Feld ip. In der Entwicklung klappt alles, in Produktion fehlen Datensätze. Der Grund ist ein Zufall der Testdaten. json_encode(['ip' => inet_pton('10.0.0.1')]) ergab {"ip":"\n\u0000\u0000\u0001"}, denn alle vier Bytes liegen unter 0x80 und gelten als gültiges UTF-8. Bei 192.0.2.1 und bei jeder IPv6-Adresse mit einem Byte ab 0x80 lieferte json_encode() dagegen false, und json_last_error_msg() meldete Malformed UTF-8 characters, possibly incorrectly encoded.

Die Rohbytes von PHP inet_pton() gehören deshalb in die Datenbank und nirgendwohin sonst. Nach außen gibt es drei Formen, und sie unterscheiden sich vor allem in der Länge:

<?php

$bin = inet_pton('2001:db8:85a3::8a2e:370:7334');
echo inet_ntop($bin), PHP_EOL;
/* 2001:db8:85a3::8a2e:370:7334 */
echo bin2hex($bin), PHP_EOL;
/* 20010db885a3000000008a2e03707334 */
echo base64_encode($bin), PHP_EOL;
/* IAENuIWjAAAAAIouA3BzNA== */

Die lesbare Form hat hier 28 Zeichen, die Hexform 32 und Base64 nur 24. Für Logs ist inet_ntop() richtig, für Schlüssel in einem Cache Base64 oder Hex. Und in Tests gehört mindestens eine Adresse mit großen Bytes wie 192.0.2.1, sonst bleibt der Fehler bis zur Produktion verborgen.

IP-Netze für IPv4 und IPv6 mit einer Funktion prüfen

Ein Admin-Bereich soll nur aus dem Firmennetz erreichbar sein, und das Netz hat ein IPv4-Präfix und ein IPv6-Präfix. Die übliche Prüfung mit ip2long() und einer Bitmaske funktioniert nur für 32 Bit, ihre Idee erklärt das Tutorial zu ip2long(). Für IPv6 findet man oft Code mit der GMP-Erweiterung, die auf vielen Servern fehlt. Dabei geht es einfacher: Der Operator & arbeitet in PHP auch auf Strings, Byte für Byte. Eine Maske aus Bytes passt deshalb auf beide Ergebnisse von PHP inet_pton().

<?php

function netzmaske(int $bits, int $bytes): string
{
$maske = str_repeat(chr(255), intdiv($bits, 8));
$rest = $bits % 8;
if ($rest > 0) {
$maske .= chr((0xff << (8 - $rest)) & 0xff);
}
return str_pad($maske, $bytes, chr(0));
}

function im_netz(string $ip, string $cidr): bool
{
[$netz, $laenge] = explode('/', $cidr, 2)
+ [1 => ''];
$a = ip_normal($ip);
$n = ip_normal($netz);
if ($a === false || $n === false
|| strlen($a) !== strlen($n)
|| !ctype_digit($laenge)
|| (int) $laenge > strlen($n) * 8) {
return false;
}
$maske = netzmaske((int) $laenge, strlen($n));
return ($a & $maske) === ($n & $maske);
}

var_dump(im_netz('2001:db8:abcd::1', '2001:db8::/32'));
/* bool(true) */
var_dump(
im_netz('::ffff:192.168.1.50', '192.168.1.0/24')
);
/* bool(true) */
var_dump(im_netz('172.32.0.5', '172.16.0.0/12'));
/* bool(false) */

netzmaske() füllt so viele ganze Bytes mit 0xff, wie die Präfixlänge hergibt, und setzt im angebrochenen Byte die oberen Bits. Für /57 ergab das ffffffffffffff800000000000000000, für /20 bei IPv4 fffff000. Die Prüfungen in im_netz() sind kein Beiwerk. Ohne den Längenvergleich würde eine IPv6-Adresse gegen ein IPv4-Netz gerechnet, ohne ctype_digit() würde aus /x die Länge 0 und damit ein Netz, das alles enthält.

Adresse Netz Ergebnis
192.168.1.50 192.168.1.0/24 true
192.168.2.50 192.168.1.0/24 false
2001:db9::1 2001:db8::/32 false
2001:db8:0:7f::1 2001:db8::/57 true
2001:db8:0:80::1 2001:db8::/57 false
10.1.2.3 0.0.0.0/0 true
2001:db8::1 0.0.0.0/0 false
192.168.1.50 /33, /, /x, ohne Präfix false

Die Grenzfälle bei /57 zeigen, dass auch Präfixe mitten in einem Byte stimmen. 0.0.0.0/0 umfasst alle IPv4-Adressen, aber keine IPv6-Adresse, denn das wäre ::/0.

IPv6-Adressen in der Datenbank: VARBINARY(16) richtig nutzen

Die Binärform passt in eine Spalte vom Typ VARBINARY(16), das steht schon in der Übersicht der Speicherformen im ip2long-Tutorial. Was dort fehlt, ist die Frage, was passiert, wenn in derselben Spalte 4 und 16 Byte liegen. Eine Analyse-Anwendung speichert das Ergebnis von PHP inet_pton() direkt und fragt das IPv6-Netz eines Kunden mit BETWEEN ab. Im Test mit MySQL 8.0 lieferte WHERE ip BETWEEN ? AND ? mit den Grenzen von 2001::/16 neben drei IPv6-Adressen auch die IPv4-Adresse 32.1.0.1. Ihre vier Bytes lauten 20010001 und beginnen damit genau wie das Netz.

Binärspalten vergleichen Byte für Byte, die Länge zählt erst, wenn alle Bytes davor gleich sind. Deshalb sortierte ORDER BY ip im Test auch 10.0.0.1, 32.1.0.1, drei IPv6-Adressen und erst dann 192.168.1.10. PHP selbst ordnet mit sort() auf den Bytes genauso gemischt. Abhilfe schafft eine einheitliche 16-Byte-Form, bei der IPv4 in der mapped-Schreibweise landet:

<?php

function als16(string $ip): string|false
{
$bin = ip_normal($ip);
if ($bin === false) {
return false;
}
if (strlen($bin) === 4) {
return str_repeat(chr(0), 10)
. str_repeat(chr(255), 2) . $bin;
}
return $bin;
}

echo bin2hex(als16('192.0.2.1')), PHP_EOL;
/* 00000000000000000000ffffc0000201 */
echo inet_ntop(als16('192.0.2.1'));
/* ::ffff:192.0.2.1 */

Mit dieser Form lieferte dieselbe Abfrage nur noch IPv6-Treffer, und der Bereich 192.168.0.0 bis 192.168.255.255 fand ::ffff:192.168.1.10. Für die Anzeige macht inet_ntop(ip_normal(inet_ntop($wert))) daraus wieder 192.168.1.10, eine IPv6-Adresse bleibt dabei unverändert. EXPLAIN zeigte range auf dem Index. Die Entscheidung gehört in die Tabellendefinition, damit sie später niemand vergisst:

<?php

$pdo->exec(
'CREATE TEMPORARY TABLE zugriffe (
id INT AUTO_INCREMENT PRIMARY KEY,
ip VARBINARY(16) NOT NULL
COMMENT "immer 16 Byte, IPv4 mapped",
INDEX (ip)
)'
);
$stmt = $pdo->prepare(
'INSERT INTO zugriffe (ip) VALUES (?)'
);
$bin = als16('192.0.2.1');
if ($bin === false) {
throw new InvalidArgumentException('IP ungültig');
}
$stmt->execute([$bin]);

Im Beispiel steht TEMPORARY, so lässt es sich gefahrlos ausprobieren. Für eine echte Tabelle fällt das Wort weg.

Ein zweiter Fehler steckt in Bestandsprojekten mit BINARY(16) statt VARBINARY(16). Die feste Länge füllt kurze Werte rechts mit Nullbytes auf. Aus den 4 Byte von 192.168.1.10 wurden im Test 16 Byte c0a8010a000000000000000000000000, und inet_ntop() machte daraus c0a8:10a::, aus 32.1.0.1 wurde 2001:1::. Weder MySQL noch PHP meldeten etwas. Mit der 16-Byte-Form spielt der Unterschied keine Rolle mehr. Für einen Altbestand gilt: Enden die 16 Byte auf zwölf Nullbytes, waren es ursprünglich 4 Byte IPv4, eine echte IPv6-Adresse mit derselben Endung lässt sich davon allerdings nicht unterscheiden.

Der dritte Fall betrifft die lesbare Ausgabe in SQL. SELECT INET6_NTOA(?) mit einem gebundenen Wert aus PHP inet_pton() ergab NULL, mit emulierten wie mit echten Prepared Statements. Der Parameter trägt den Zeichensatz der Verbindung und gilt nicht als Binärwert. Ein CAST behebt das:

<?php

$sql = 'SELECT INET6_NTOA(CAST(? AS BINARY))';
$stmt = $pdo->prepare($sql);
$stmt->execute([inet_pton('2001:db8::1')]);
echo $stmt->fetchColumn();
/* 2001:db8::1 */

Gespeicherte Spalten liest INET6_NTOA(ip) ohne Umweg, und INET6_ATON() erzeugt dieselben Bytes wie PHP inet_pton(), der Vergleich ergab 1. Der letzte Stolperstein ist ein ungeprüftes false: $stmt->execute([inet_pton('kaputt')]) schrieb ohne Fehler einen leeren Wert in die Spalte, weder NULL noch eine Meldung. Vor jedem execute() gehört deshalb die Prüfung auf === false. Im Beispiel oben bricht dann eine Exception den Insert ab, wer weiterarbeiten will, protokolliert die abgelehnte Adresse, statt sie zu speichern. PostgreSQL bringt mit inet übrigens einen eigenen Spaltentyp für Adressen mit, dort entfällt die Umwandlung.

Praxis: eine Sperrliste mit PHP inet_pton()

Die Sperrliste setzt die Bausteine zusammen. Sie nimmt Netze in CIDR-Schreibweise für beide Protokolle an, prüft jedes Netz schon beim Eintragen und behandelt jede Adresse vor dem Vergleich mit ip_aus_text() und ip_normal(). Ein ungültiges Netz wird erkannt, weil ein gültiges Netz immer sich selbst enthält:

<?php

final class Sperrliste
{
/** @var list<string> */
private array $netze = [];

public function sperre(string $cidr): void
{
[$netz] = explode('/', $cidr, 2);
if (!im_netz($netz, $cidr)) {
throw new InvalidArgumentException(
"Kein Netz: $cidr"
);
}
$this->netze[] = $cidr;
}

public function gesperrt(string $roh): bool
{
$ip = ip_aus_text($roh);
if ($ip === false) {
return true;
}
foreach ($this->netze as $cidr) {
if (im_netz($ip, $cidr)) {
return true;
}
}
return false;
}
}

$liste = new Sperrliste();
$liste->sperre('203.0.113.0/24');
$liste->sperre('2001:db8:bad::/48');
var_dump($liste->gesperrt('::ffff:203.0.113.9'));
/* bool(true) */

Eine Adresse, die sich nicht lesen lässt, gilt als gesperrt. Für einen Admin-Bereich ist das die richtige Wahl, für eine öffentliche Seite würde man eher protokollieren und durchlassen. Unter Windows und Linux ergaben sich dieselben Antworten:

Eingabe Ergebnis
203.0.113.9 gesperrt
::ffff:203.0.113.9 gesperrt
198.51.100.1 frei
2001:db8:bad:1::7 gesperrt
[2001:db8:bad::1]:443 gesperrt
2001:db8:900d::1 frei
fe80::1%eth0 frei
kaputt gesperrt
sperre('2001:db8::/x') InvalidArgumentException: Kein Netz: 2001:db8::/x
sperre('300.1.1.0/24') InvalidArgumentException: Kein Netz: 300.1.1.0/24

inet_ntop() und die eindeutige Schreibweise

Eine IPv6-Adresse lässt sich auf viele Arten schreiben. '2001:DB8::1' === '2001:db8:0::1' ist false, die Bytes beider Schreibweisen sind dagegen gleich. Wer Adressen aus Formularen als Text speichert, bekommt so doppelte Einträge. filter_var('2001:DB8::1', FILTER_VALIDATE_IP) hilft nicht, es gibt die Eingabe unverändert zurück. Eindeutig wird eine Adresse erst durch den Weg hin und zurück: inet_ntop(inet_pton('2001:0db8:0000::0001')) ergab 2001:db8::1, und 0:0:0:0:0:FFFF:204.152.189.116 wurde zu ::ffff:204.152.189.116. Diese Form taugt als Schlüssel und für die Anzeige.

Fazit

PHP inet_pton() macht aus IPv4 und IPv6 Bytes, mit denen sich rechnen und speichern lässt. Die Funktion warnt aber nie. Führende Nullen, Ports, Klammern, Zonen-IDs und Präfixe führen nur zu false, und ein ungeprüftes false landet als leerer Wert in der Datenbank.

Drei Regeln halten den Code verlässlich. Jede Adresse geht vor dem Vergleich durch eine Normalform, damit ::ffff:-Adressen und reine IPv4 gleich aussehen. Eine Spalte enthält nur eine Länge, am einfachsten immer 16 Byte in VARBINARY(16). Und Rohbytes verlassen die Datenbankschicht nicht, nach außen gehen inet_ntop(), Hex oder Base64. Mit der Bytemaske prüft dieselbe Funktion Netze beider Protokolle, ganz ohne Zusatzerweiterung.

 


 

Kommentare (0)

Noch keine Kommentare. Sei der Erste!

Melde dich an, um einen Kommentar zu schreiben.
Bücherregal mit drei Büchern: 'PHP 4 - Grundlagen und Profiwissen' von Hanser Verlag, 'Webdesign in a Nutshell' von O'Reilly Verlag, und 'Webgestaltung' von Galileo Computing.