16. Netzwerkfunktionen
Wir besprechen nun die Netzwerkfunktionen von PHP, mit denen sich TCP / IP (Transmission Control Protocol / Internet Protocol) programmieren lässt. Die Skripte dieses Kapitels befinden sich im Ordner [scripts-console/inet] des Kurscodes:
| php8-oct-2026
└── scripts-console
└── inet
├── http
├── imap
├── ip
├── mailpit
├── smtp
└── utilities
|
16.1. Grundlagen der Webprogrammierung
16.1.1. Allgemeines
Betrachten wir die Kommunikation zwischen zwei entfernten Rechnern A und B:

Wenn eine Anwendung AppA auf Rechner A mit einer Anwendung AppB auf Rechner B im Internet kommunizieren möchte, muss sie mehrere Dinge wissen:
- die IP-Adresse (Internet Protocol) oder den Namen von Rechner B;
- die Portnummer, die die Anwendung AppB verwendet. Auf Rechner B können nämlich viele Anwendungen laufen, die im Internet arbeiten. Wenn er Informationen aus dem Netzwerk empfängt, muss er wissen, für welche Anwendung die Informationen bestimmt sind. Die Anwendungen auf Rechner B greifen über Schnittstellen, auch Kommunikationsports genannt, auf das Netzwerk zu. Diese Information steckt in dem Paket, das Rechner B empfängt, damit er es an die richtige Anwendung ausliefern kann;
- die Kommunikationsprotokolle, die Rechner B versteht. In unserer Untersuchung verwenden wir nur die Protokolle TCP / IP;
- das Kommunikationsprotokoll, das die Anwendung AppB unterstützt. Die Rechner A und B „unterhalten“ sich nämlich miteinander. Was sie sagen, wird in die Protokolle TCP und IP verpackt. Wenn jedoch am anderen Ende der Kette die Anwendung AppB die von der Anwendung AppA gesendeten Informationen empfängt, muss sie in der Lage sein, sie zu interpretieren. Das ist vergleichbar mit zwei Personen A und B, die telefonieren: Ihr Gespräch wird vom Telefon übertragen. Die Sprache wird von Telefon A in Signale kodiert, über die Telefonleitungen übertragen und kommt bei Telefon B an, um dekodiert zu werden. Person B hört dann die Sprache. Hier kommt der Begriff des Kommunikationsprotokolls ins Spiel: Wenn A Französisch spricht und B diese Sprache nicht versteht, können A und B nicht sinnvoll miteinander kommunizieren.
Die beiden kommunizierenden Anwendungen müssen sich daher auf die Art des Dialogs einigen, den sie verwenden. Der Dialog mit einem Dienst namens FTP ist beispielsweise nicht derselbe wie der mit einem Dienst namens POP: Diese beiden Dienste akzeptieren nicht dieselben Befehle. Sie haben unterschiedliche Dialogprotokolle.
16.1.2. Eigenschaften des TCP-Protokolls
Wir beschäftigen uns hier nur mit der Netzwerkkommunikation über das Transportprotokoll TCP, dessen Haupteigenschaften wie folgt lauten:
- Der Prozess, der Daten übertragen möchte, baut zunächst eine Verbindung zu dem Prozess auf, der die Informationen empfangen soll. Diese Verbindung wird zwischen einem Port des sendenden Rechners und einem Port des empfangenden Rechners hergestellt. Zwischen den beiden Ports entsteht so ein virtueller Pfad, der ausschließlich den beiden Prozessen vorbehalten ist, die die Verbindung aufgebaut haben;
- Alle vom Quellprozess gesendeten Pakete folgen diesem virtuellen Pfad und kommen in der Reihenfolge an, in der sie gesendet wurden;
- Die übertragenen Daten erscheinen kontinuierlich. Der sendende Prozess sendet Daten in seinem eigenen Tempo. Diese Daten werden nicht unbedingt sofort gesendet: Das TCP-Protokoll wartet, bis es genügend Daten zum Senden hat. Sie werden in einer Struktur namens TCP-Segment abgelegt. Sobald dieses Segment gefüllt ist, wird es an die IP-Schicht übergeben, wo es in ein IP-Paket verpackt wird;
- Jedes vom TCP-Protokoll gesendete Segment ist nummeriert. Das empfangende TCP-Protokoll prüft, ob es die Segmente in der richtigen Reihenfolge empfängt. Für jedes korrekt empfangene Segment sendet es dem Absender eine Bestätigung;
- Wenn der Absender diese Bestätigung erhält, benachrichtigt er den sendenden Prozess. Der sendende Prozess kann somit bestätigen, dass ein Segment erfolgreich zugestellt wurde;
- Erhält das TCP-Protokoll, das ein Segment gesendet hat, nach einer gewissen Zeit keine Bestätigung, sendet es das betreffende Segment erneut und gewährleistet so die Qualität des Dienstes zur Informationszustellung;
- Der zwischen den beiden kommunizierenden Prozessen aufgebaute virtuelle Kanal ist vollduplex: Das bedeutet, dass Informationen in beide Richtungen fließen können. Der Zielprozess kann also Bestätigungen senden, auch während der Quellprozess weiter Informationen sendet. Dadurch kann das TCP-Protokoll der Quelle beispielsweise mehrere Segmente senden, ohne auf eine Bestätigung zu warten. Stellt es nach einer gewissen Zeit fest, dass es für ein bestimmtes Segment Nr. n keine Bestätigung erhalten hat, setzt es das Senden der Segmente ab dieser Stelle fort.
16.1.3. Die Client-Server-Beziehung
Die Kommunikation im Internet ist häufig asymmetrisch: Rechner A baut eine Verbindung auf, um einen Dienst von Rechner B anzufordern. Er gibt an, dass er eine Verbindung zum Dienst SB1 von Rechner B herstellen möchte. Rechner B nimmt die Anfrage entweder an oder lehnt sie ab. Nimmt er sie an, kann Rechner A seine Anfragen an den Dienst SB1 senden. Diese Anfragen müssen dem Kommunikationsprotokoll entsprechen, das der Dienst SB1 versteht. Zwischen Rechner A, dem Client-Rechner, und Rechner B, dem Server-Rechner, entsteht so ein Dialog aus Anfrage und Antwort. Einer der beiden Partner beendet die Verbindung.
16.1.4. Client-Architektur
Die Architektur eines Netzwerkprogramms, das Dienste von einer Serveranwendung anfordert, sieht wie folgt aus:
| open the connection with the SB1 service of machine B
if successful then
while not finished
prepare a request
send it to machine B
wait for and retrieve the response
process it
end while
end if
close the connection
|
16.1.5. Server-Architektur
Die Architektur eines Programms, das Dienste anbietet, sieht wie folgt aus:
| open the service on the local machine
while the service is open
listen for connection requests on a port called the listening port
when there is a request, have it handled by another task on another port called the service port
end while
|
Das Serverprogramm behandelt die erste Verbindungsanfrage eines Clients anders als seine späteren Dienstanfragen. Das Programm erbringt den Dienst nicht selbst. Täte es das, würde es während der Dienstausführung nicht mehr auf Verbindungsanfragen lauschen, und Clients würden nicht bedient. Es geht daher anders vor: Sobald eine Verbindungsanfrage am Lauschport eingeht und angenommen wird, erzeugt der Server eine Task, die den vom Client angeforderten Dienst erbringt. Dieser Dienst wird an einem anderen Port des Server-Rechners erbracht, dem sogenannten Dienstport. So können mehrere Clients gleichzeitig bedient werden.
Eine Dienst-Task hat die folgende Struktur:
| while the service has not been fully provided
wait for a request on the service port
when there is one, build the response
send the response through the service port
end while
release the service port
|
Eine andere Möglichkeit, mehrere Clients gleichzeitig zu bedienen, ohne Tasks zu erzeugen, besteht darin, den Lauschport und die Dienstports gleichzeitig mit einer Funktion zu überwachen, die wartet, bis einer von ihnen etwas zu melden hat. Genau das tut der TCP-Server, den wir schreiben werden, mithilfe der PHP-Funktion [stream_select].
16.2. Internetprotokolle erkunden
16.2.1. Einführung
Wenn sich ein Client mit einem Server verbindet, entsteht zwischen beiden ein Dialog. Die Art dieses Dialogs bildet das sogenannte Kommunikationsprotokoll des Servers. Zu den gebräuchlichsten Internetprotokollen gehören die folgenden:
- HTTP: HyperText Transfer Protocol – das Protokoll zur Kommunikation mit einem Webserver (HTTP-Server);
- SMTP: Simple Mail Transfer Protocol – das Protokoll zur Kommunikation mit einem Server zum Versenden von E-Mails (SMTP-Server);
- POP: Post Office Protocol – das Protokoll zur Kommunikation mit einem Server zur Speicherung von E-Mails (POP-Server). Es dient zum Abrufen empfangener E-Mails, nicht zum Versenden;
- IMAP: Internet Message Access Protocol – das Protokoll zur Kommunikation mit einem Server zur Speicherung von E-Mails (IMAP-Server). Dieses Protokoll hat das ältere POP-Protokoll nach und nach abgelöst;
- FTP: File Transfer Protocol – das Protokoll zur Kommunikation mit einem Server zur Speicherung von Dateien (FTP-Server).
Alle diese Protokolle sind textbasiert: Client und Server tauschen Textzeilen aus. Wenn Sie einen Client haben, der in der Lage ist,
- eine Verbindung zu einem TCP-Server herzustellen,
- die vom Server gesendeten Textzeilen auf der Konsole anzuzeigen und
- die Textzeilen, die ein Benutzer über die Tastatur eingeben würde, an den Server zu senden,
dann können wir mit einem TCP-Server kommunizieren, der ein textbasiertes Protokoll verwendet, sofern wir die Regeln dieses Protokolls kennen.
16.2.2. TCP-Hilfsprogramme
Der PHP-7-Kurs stellte zwei Windows-Hilfsprogramme bereit, [RawTcpClient] und [RawTcpServer], die in C# geschrieben waren. Hier ersetzen wir sie durch zwei PHP-Skripte, die wir uns gleich ansehen: Das ist eine Gelegenheit, die Netzwerkfunktionen von PHP kennenzulernen. Sie befinden sich im Ordner [inet/utilities]:
| utilities
├── keyboard.php
├── tcp-client.php
└── tcp-server.php
|
- [tcp-client.php] ermöglicht die Verbindung mit Port P des Servers S;
- [tcp-server.php] erstellt einen Server, der auf Port P auf Clients lauscht;
- [keyboard.php] enthält zwei Funktionen, die von den beiden vorherigen Skripten verwendet werden.
Beachten Sie, dass es für diese Art von Tests auch fertige Werkzeuge gibt. Unter Windows prüft der PowerShell-Befehl [Test-NetConnection localhost -Port 80] einfach, ob ein Dienst an einem Port antwortet. Das Werkzeug [curl], dem wir beim HTTP-Protokoll begegnen werden, kann mit vielen Servern kommunizieren, und seine Option [-v] (verbose) zeigt den Austausch zwischen Client und Server an. Unsere beiden Skripte lassen uns dagegen die Protokollbefehle selbst eintippen.
16.2.2.1. Der Server [tcp-server.php]
Der TCP-Server [tcp-server.php] wird mit der Syntax [php tcp-server.php port] aufgerufen, um einen TCP-Dienst an Port [port] des lokalen Rechners (des Computers, an dem Sie arbeiten) zu erstellen:
- Der Server kann mehrere Clients gleichzeitig bedienen;
- Der Server führt die Befehle aus, die der Benutzer über die Tastatur eingibt. Diese Befehle lauten wie folgt:
- list: listet die Clients auf, die aktuell mit dem Server verbunden sind. Sie werden im Format [id=x - name=y] angezeigt. Das Feld [id] dient zur Identifizierung der Clients;
- send x [text]: sendet Text an Client Nr. x (id=x). Die eckigen Klammern [] werden nicht gesendet. Sie sind im Befehl erforderlich. Sie dienen dazu, den an den Client gesendeten Text optisch abzugrenzen;
- close x: schließt die Verbindung mit Client Nr. x;
- quit: schließt alle Verbindungen und beendet den Dienst;
- Zeilen, die ein Client an den Server sendet, werden auf der Konsole angezeigt;
- Die gesamte Kommunikation mit einem Client wird in einer Textdatei namens [logs/machine-port.txt], protokolliert, wobei [machine-port] den Client identifiziert (seine IP-Adresse und den von ihm verwendeten Port).
Der Servercode lautet wie folgt:
| <?php
declare(strict_types=1);
// generischer TCP-Server
// Syntax: php tcp-server.php port
// - wartet auf Clients am Port [port] des lokalen Rechners und kann mehrere gleichzeitig bedienen;
// - zeigt die von den Clients gesendeten Textzeilen an;
// - führt die über die Tastatur eingegebenen Befehle aus:
// list: listet die verbundenen Clients auf;
// send id [text]: sendet [text] (ohne die Klammern) an den Client Nr. id;
// close id: schließt die Verbindung zum Client Nr. id;
// quit: schließt alle Verbindungen und beendet den Server;
// - protokolliert den Austausch mit jedem Client in der Datei [logs/machine-port.txt]
// wobei [machine-port] den Client identifiziert
require_once __DIR__ . "/keyboard.php";
// Analyse der Befehlszeilenargumente
if (count($argv) !== 2 || !ctype_digit($argv[1])) {
print "Syntax: php tcp-server.php port\n";
exit(1);
}
$port = $argv[1];
// Öffnen des Dienstes auf allen Netzwerkschnittstellen des lokalen Rechners
$server = @stream_socket_server("tcp://0.0.0.0:$port", $errorNumber, $error);
if ($server === false) {
print "Unable to open the service on the port [$port]: $error\n";
exit(2);
}
print "Server listening on the port [$port]\n";
print "Commands: list, send id [text], close id, quit\n";
if (!is_dir(__DIR__ . "/logs")) {
mkdir(__DIR__ . "/logs");
}
// die verbundenen Clients: id => [socket, name, log file, buffer]
$clients = [];
$nextId = 1;
// die Tastatur wird von einem Kindprozess gelesen
[$reader, $keyboard] = startKeyboardReader();
$echo = !stream_isatty(STDIN);
$keyboardBuffer = "";
// Dienstschleife
$done = false;
while (!$done) {
// wir überwachen: den Listening-Port, die Clients und die Tastatur
$reads = [$server, $keyboard, ...array_column($clients, "socket")];
$writes = $exceptions = null;
stream_select($reads, $writes, $exceptions, null);
foreach ($reads as $stream) {
if ($stream === $server) {
// ein neuer Client verbindet sich
$socket = stream_socket_accept($server, 0, $name);
if ($socket !== false) {
$id = $nextId++;
$log = fopen(__DIR__ . "/logs/" . str_replace(":", "-", $name) . ".txt", "w");
$clients[$id] = ["socket" => $socket, "name" => $name, "log" => $log, "buffer" => ""];
print "Client no. $id [$name] connected\n";
}
} elseif ($stream === $keyboard) {
// ein Befehl wurde über die Tastatur eingegeben
$data = fread($keyboard, 8192);
if ($data === false || $data === "") {
// Ende der Standardeingabe: wir beenden den Server
$done = true;
break;
}
foreach (extractLines($keyboardBuffer, $data) as $command) {
if ($echo) {
print "$command\n";
}
if (execute($command, $clients)) {
$done = true;
break;
}
}
} else {
// ein Client hat gesprochen
$id = array_find_key($clients, fn(array $client): bool => $client["socket"] === $stream);
if ($id === null) {
// Client wurde zwischenzeitlich durch den Befehl [close] geschlossen
continue;
}
$data = fread($stream, 8192);
if ($data === false || $data === "") {
print "The client no. $id has closed the connection\n";
close($clients, $id);
continue;
}
foreach (extractLines($clients[$id]["buffer"], $data) as $line) {
print "<-- client no. $id [$line]\n";
fwrite($clients[$id]["log"], "<-- [$line]\n");
}
}
}
}
// Beenden des Dienstes
foreach (array_keys($clients) as $id) {
close($clients, $id);
}
fclose($server);
proc_terminate($reader);
print "Server stopped\n";
// --------------------------------------------------------------------------
// führt einen über die Tastatur eingegebenen Befehl aus - gibt true zurück, wenn es der Befehl [quit] ist
function execute(string $command, array &$clients): bool
{
// send id [text]
if (preg_match('/^send\s+(\d+)\s+\[(.*)\]$/', $command, $fields)) {
$id = (int) $fields[1];
if (!isset($clients[$id])) {
print "Unknown client no. $id\n";
} else {
fwrite($clients[$id]["socket"], "$fields[2]\r\n");
fwrite($clients[$id]["log"], "--> [$fields[2]]\n");
}
return false;
}
// die anderen Befehle
$words = preg_split('/\s+/', trim($command));
switch ($words[0]) {
case "list":
foreach ($clients as $id => $client) {
print "id=$id - name={$client["name"]}\n";
}
return false;
case "close":
$id = (int) ($words[1] ?? 0);
if (!isset($clients[$id])) {
print "Unknown client no. $id\n";
} else {
close($clients, $id);
print "Connection with the client no. $id closed\n";
}
return false;
case "quit":
return true;
default:
print "Unknown command [$command]. Commands: list, send id [text], close id, quit\n";
return false;
}
}
// --------------------------------------------------------------------------
// schließt die Verbindung zum Client Nr. [$id]
function close(array &$clients, int $id): void
{
fclose($clients[$id]["socket"]);
fclose($clients[$id]["log"]);
unset($clients[$id]);
}
|
Kommentare:
- Zeile 17: Die Datei [keyboard.php] wird geladen; darauf kommen wir später zurück;
- Zeile 20: Das Array [$argv] enthält die Kommandozeilenargumente. [$argv[0]] ist der Name des Skripts, [$argv[1]] ist das erste Argument, hier die Portnummer. Die Funktion [ctype_digit] prüft, ob die Portnummer nur aus Ziffern besteht;
- Zeile 27: Die Funktion [stream_socket_server] startet einen TCP-Dienst. Ihr erster Parameter ist eine Adresse der Form [tcp://interface:port]. Die Schnittstelle [0.0.0.0] bezeichnet alle Netzwerkschnittstellen des Rechners: Der Server ist sowohl über [localhost] als auch über die IP-Adresse des Rechners im lokalen Netzwerk erreichbar. Im Fehlerfall (z. B. wenn der Port bereits belegt ist) gibt die Funktion [false] zurück und speichert eine Fehlernummer und eine Fehlermeldung in den beiden Variablen, die als zweiter und dritter Parameter übergeben werden. Der Operator [@] verhindert, dass PHP seine eigene Warnung ausgibt: Wir zeigen unsere eigene Meldung an;
- Zeile 39: das Dictionary der verbundenen Clients. Jeder Client wird durch seinen Socket (die Verbindung zwischen ihm und dem Server), seinen Namen [address:port], seine Protokolldatei und einen Puffer beschrieben, dessen Zweck wir noch erläutern werden;
- Zeile 42: Die Tastatur wird von einem Kindprozess gelesen. Warum, sehen wir bei der Datei [keyboard.php]. [$keyboard] ist ein Stream, in den die über die Tastatur eingegebenen Zeilen eingespeist werden;
- Zeile 43: Die Funktion [stream_isatty] stellt fest, ob die Standardeingabe die Tastatur (ein Terminal) ist oder nicht. Wurde die Standardeingabe in eine Datei umgeleitet ([php tcp-server.php 100 < commands.txt]), werden die gelesenen Befehle nicht auf dem Bildschirm angezeigt. Der Server zeigt sie dann selbst an;
- Zeilen 48–52: die Dienstschleife. In jeder Iteration wartet der Server darauf, dass einer der überwachten Streams ihm etwas mitzuteilen hat: der Lauschport (ein neuer Client verbindet sich), die Tastatur (ein Befehl wurde eingegeben) oder einer der Clients (er hat Text gesendet). Der Operator [...] zerlegt das Array der Client-Sockets (das mit [array_column] gewonnen wird) in das Array [$reads];
- Zeile 52: Die Funktion [stream_select] wartet, bis einer der Streams im Array [$reads] lesbar ist. Der letzte Parameter [null], bedeutet: unbegrenzt warten. Bei der Rückkehr hat die Funktion die Streams, in denen nichts zu lesen ist, aus dem Array [$reads] entfernt. Der zweite und der dritte Parameter betreffen die Streams, in die wir schreiben möchten, sowie außergewöhnliche Ereignisse: Sie interessieren uns nicht. Da sie als Referenz übergeben werden, müssen wir ihnen Variablen übergeben – hier [$writes] und [$exceptions], die gleich [null] sind;
- Zeilen 54–60: Ein neuer Client verbindet sich. Die Funktion [stream_socket_accept] nimmt die Verbindung an. Sie liefert den Dienst-Socket, der den Server mit diesem Client verbindet, und speichert die Identität des Clients in [$name] in der Form [address:port]. Ein Timeout von 0 bedeutet, dass nicht gewartet wird: [stream_select] hat uns mitgeteilt, dass ein Client wartete;
- Zeilen 63–75: Ein Befehl wurde über die Tastatur eingegeben. Die Funktion [fread] liest alles, was verfügbar ist (bis zu 8.192 Byte). Ein leerer String bedeutet, dass der Stream geschlossen wurde. Die Funktion [extractLines] zerlegt das Gelesene in vollständige Zeilen;
- Zeilen 81–95: Ein Client hat Text gesendet. Die Funktion [array_find_key] (PHP 8.4) liefert den Schlüssel des ersten Array-Elements, das die Bedingung erfüllt, die die als zweiter Parameter übergebene Pfeilfunktion [fn] ausdrückt: So wird die ID des Clients anhand seines Sockets ermittelt. Gibt [fread] einen leeren String zurück, hat der Client die Verbindung geschlossen. Andernfalls wird jede empfangene Zeile angezeigt und in der Protokolldatei des Clients aufgezeichnet;
- Zeilen 110–141: Die Funktion [execute] führt einen über die Tastatur eingegebenen Befehl aus. Der Befehl [send id [text]] wird durch einen regulären Ausdruck erkannt. Der Text wird an den Client gesendet, gefolgt von der Sequenz \r\n: Internetprotokolle beenden Textzeilen mit den beiden Zeichen CR (\r) und LF (\n);
- Zeile 150: Die Funktion [close] schließt die Verbindung zu einem Client und entfernt ihn aus dem Dictionary [$clients], das als Referenz übergeben wird ([&]).
16.2.2.2. Die Datei [keyboard.php]
Die Datei [keyboard.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// von [tcp-client.php] und [tcp-server.php] gemeinsam genutzte Werkzeuge
// --------------------------------------------------------------------------
// startet einen Kindprozess, der die Tastatur liest und uns jede eingegebene Zeile
// über einen Socket zurücksendet. Warum? Unsere Programme müssen mit der Funktion [stream_select] gleichzeitig das Netzwerk und die
// Tastatur überwachen. Unter Windows kann [stream_select] aber
// nur Sockets überwachen, nicht die Tastatur (STDIN).
// Der Deskriptor ['socket'] von [proc_open] (PHP 8.0) verbindet den Kindprozess über einen Socket mit dem
// Elternprozess, den [stream_select] auf jedem Betriebssystem überwachen kann.
// gibt den Kindprozess und den Socket zurück, der die über die Tastatur eingegebenen Zeilen liefert
function startKeyboardReader(): array
{
$process = proc_open(
// der Kindprozess: ein einzeiliges PHP-Skript, das seine Eingabe auf seine Ausgabe kopiert
[PHP_BINARY, "-r", 'while (($line = fgets(STDIN)) !== false) { echo $line; }'],
// seine Eingabe ist unsere Tastatur, seine Ausgabe ist ein Socket
[0 => STDIN, 1 => ["socket"], 2 => STDERR],
$pipes
);
if ($process === false) {
throw new RuntimeException("Unable to start the keyboard reader");
}
return [$process, $pipes[1]];
}
// --------------------------------------------------------------------------
// hängt die Bytes [$data] an den Puffer [$buffer] an und extrahiert daraus die vollständigen Zeilen,
// zurückgegeben ohne ihr Zeilenende-Zeichen (\n oder \r\n);
// das Ende des Puffers (eine unvollständige Zeile) bleibt im Puffer
function extractLines(string &$buffer, string $data): array
{
$buffer .= $data;
$lines = explode("\n", $buffer);
// das letzte Element ist die aktuelle, noch nicht beendete Zeile
$buffer = array_pop($lines);
return array_map(fn(string $line): string => rtrim($line, "\r"), $lines);
}
|
Kommentare:
- Zeile 15: Unsere beiden Skripte müssen gleichzeitig das Netzwerk und die Tastatur überwachen. Unter Linux oder macOS könnten wir den Stream [STDIN] (die Tastatur) an [stream_select] übergeben. Unter Windows ist das nicht möglich: [stream_select] kann dort nur Sockets überwachen. Der Ausweg besteht darin, einen zweiten Prozess die Tastatur lesen zu lassen, der uns die eingegebenen Zeilen über einen Socket sendet;
- Zeilen 17–22: Die Funktion [proc_open] startet einen Kindprozess. Ihr erster Parameter ist der auszuführende Befehl in Form eines Arrays: der aktuell laufende PHP-Interpreter ([PHP_BINARY]) mit der Option [-r], die den als Argument übergebenen PHP-Code ausführt. Dieser Code kopiert jede aus seiner Eingabe gelesene Zeile in seine Ausgabe. Der zweite Parameter beschreibt die Streams des Kindprozesses: Seine Eingabe (0) ist unsere Standardeingabe (die Tastatur), seine Ausgabe (1) ist ein von PHP erzeugter Socket (Deskriptor [['socket']], verfügbar seit PHP 8.0), und seine Fehler (2) werden an unsere Fehlerausgabe geleitet. Der dritte Parameter erhält die erzeugten Streams: [$pipes[1]] ist unser Ende des Sockets;
- Zeile 34: Wenn [stream_select] signalisiert, dass ein Stream lesebereit ist, liefert [fread] das Empfangene: Das kann eine Zeile, mehrere Zeilen oder ein Teil einer Zeile sein. Die Funktion [extractLines] fügt diese Bytes dem Puffer [$buffer] hinzu (als Referenz übergeben), extrahiert daraus die vollständigen Zeilen und belässt die unvollständige Zeile im Puffer. Beachten Sie die Pfeilfunktion [fn(string $line): string => rtrim($line, "\r")], die das abschließende \r von Zeilen entfernt, die mit \r\n enden.
Wir hätten die Zeilen mit der Funktion [fgets] lesen können. [fgets] liest die Daten jedoch blockweise und legt die Zeilen, die es noch nicht zurückgegeben hat, in einem internen Puffer von PHP ab. [stream_select], das nur das Netzwerk überwacht, würde sie nicht sehen. Das Lesen mit [fread] und das eigene Zerlegen in Zeilen vermeidet diese Falle.
16.2.2.3. Der Client [tcp-client.php]
Der TCP-Client [tcp-client.php] wird mit der Syntax [php tcp-client.php [--quit command] [--tls] server port] aufgerufen, um sich mit Port [port] des Servers [server] zu verbinden:
- Die vom Benutzer über die Tastatur eingegebenen Zeilen werden an den Server gesendet;
- Die vom Server gesendeten Zeilen werden auf der Konsole angezeigt, sobald sie eintreffen;
- Die gesamte Kommunikation wird in einer Textdatei namens [logs/server-port.txt] protokolliert;
- Der Befehl [quit] beendet den Client. Mit der Option [--quit] können Sie einen anderen Befehl wählen;
- Die Option [--tls] verschlüsselt die Verbindung. Wir benötigen sie, um mit gesicherten Servern zu kommunizieren.
Sein Code lautet wie folgt:
| <?php
declare(strict_types=1);
// generischer TCP-Client
// Syntax: php tcp-client.php [--quit command] [--tls] server port
// - verbindet sich mit dem Port [port] des Rechners [server];
// - zeigt die vom Server gesendeten Textzeilen an, sobald sie eintreffen;
// - sendet die über die Tastatur eingegebenen Textzeilen an den Server;
// - protokolliert den gesamten Austausch in der Datei [logs/server-port.txt]
// Optionen:
// --quit command: der Befehl, der den Client beendet ([quit] standardmäßig)
// --tls: die Verbindung wird verschlüsselt (TLS), sobald sie geöffnet ist
require_once __DIR__ . "/keyboard.php";
// Analyse der Befehlszeilenargumente
$quit = "quit";
$tls = false;
$arguments = [];
for ($i = 1; $i < count($argv); $i++) {
match ($argv[$i]) {
"--quit" => $quit = $argv[++$i] ?? $quit,
"--tls" => $tls = true,
default => $arguments[] = $argv[$i],
};
}
if (count($arguments) !== 2 || !ctype_digit($arguments[1])) {
print "Syntax: php tcp-client.php [--quit command] [--tls] server port\n";
exit(1);
}
[$server, $port] = $arguments;
// Öffnen der Verbindung zum Server
// mit --tls wird das Serverzertifikat nicht geprüft: dies ist ein Entdeckungswerkzeug
$context = stream_context_create(["ssl" => ["verify_peer" => false, "verify_peer_name" => false]]);
$transport = $tls ? "tls" : "tcp";
$connection = @stream_socket_client("$transport://$server:$port", $errorNumber, $error, 10,
STREAM_CLIENT_CONNECT, $context);
if ($connection === false) {
print "Failed to connect to the server [$server:$port]: $error\n";
exit(2);
}
$client = stream_socket_get_name($connection, false);
print "Client [$client] connected to the server [$server:$port]\n";
print "Type your commands ($quit to stop):\n";
// Protokolldatei
if (!is_dir(__DIR__ . "/logs")) {
mkdir(__DIR__ . "/logs");
}
$log = fopen(__DIR__ . "/logs/$server-$port.txt", "w");
// die Tastatur wird von einem Kindprozess gelesen
[$reader, $keyboard] = startKeyboardReader();
// wenn die Standardeingabe eine Datei ist (php tcp-client.php ... < commands.txt),
// werden die gelesenen Befehle nicht auf dem Bildschirm angezeigt: wir zeigen sie selbst an
$echo = !stream_isatty(STDIN);
// Puffer der unvollständigen Zeilen, die vom Server und von der Tastatur empfangen wurden
$serverBuffer = "";
$keyboardBuffer = "";
// Dialogschleife mit dem Server
$done = false;
while (!$done) {
// wir warten, bis der Server oder die Tastatur uns etwas mitzuteilen hat
$reads = $keyboard !== null ? [$connection, $keyboard] : [$connection];
$writes = $exceptions = null;
// ohne Tastatur (Ende der Standardeingabe) warten wir höchstens 2 Sekunden auf den Server
if (stream_select($reads, $writes, $exceptions, $keyboard !== null ? null : 2) === 0) {
break;
}
// hat der Server gesprochen?
if (in_array($connection, $reads, true)) {
$data = fread($connection, 8192);
if ($data === false || $data === "") {
// der Server hat die Verbindung geschlossen
if ($serverBuffer !== "") {
display("<-- [$serverBuffer]", $log);
}
print "Connection with the server lost...\n";
break;
}
foreach (extractLines($serverBuffer, $data) as $line) {
display("<-- [$line]", $log);
}
}
// wurde über die Tastatur eine Zeile eingegeben?
if ($keyboard !== null && in_array($keyboard, $reads, true)) {
$data = fread($keyboard, 8192);
if ($data === false || $data === "") {
// Ende der Standardeingabe
$keyboard = null;
continue;
}
foreach (extractLines($keyboardBuffer, $data) as $command) {
if ($echo) {
print "$command\n";
}
// Ende des Clients?
if ($command === $quit) {
$done = true;
break;
}
// wir senden den Befehl an den Server: die Internetprotokolle
// beenden die Zeilen mit der Sequenz \r\n
fwrite($connection, "$command\r\n");
fwrite($log, "--> [$command]\n");
}
}
}
// Schließen der Verbindung, der Protokolldatei und des Tastaturlesers
fclose($connection);
fclose($log);
proc_terminate($reader);
print "End of the client\n";
// --------------------------------------------------------------------------
// zeigt eine empfangene Zeile an und protokolliert sie in der Protokolldatei
function display(string $line, $log): void
{
print "$line\n";
fwrite($log, "$line\n");
}
|
Kommentare:
- Zeilen 21–26: Auswertung der Argumente. Der Ausdruck [match] (PHP 8.0) vergleicht sein Argument mit den Werten seiner Zweige mithilfe des Operators [===] und wertet den entsprechenden Zweig aus. Hier ist jeder Zweig eine Zuweisung. [$argv[++$i] ?? $quit] liefert das Argument, das auf [--quit] folgt, falls es existiert, und andernfalls [$quit] ;
- Zeile 32: Array-Entpacken: [$server] erhält [$arguments[0]], und [$port] erhält [$arguments[1]];
- Zeilen 36–39: Die Funktion [stream_socket_client] stellt eine Verbindung zum Dienst [tcp://server:port] her. Mit der Option [--tls] lautet die Adresse [tls://server:port]: PHP verschlüsselt die Verbindung dann mit dem TLS-Protokoll (Transport Layer Security). Der von [stream_context_create] erzeugte Kontext legt hier fest, dass das Serverzertifikat nicht geprüft werden soll: Für ein Erkundungswerkzeug vermeidet das Probleme mit Testservern, die selbstsignierte Zertifikate haben. Der vierte Parameter ist die maximale Zeit (in Sekunden), die für den Verbindungsaufbau zur Verfügung steht;
- Zeile 44: Die Funktion [stream_socket_get_name] gibt an, ob eine Verbindung lokal (false) oder entfernt (true) ist, in der Form [address:port];
- Zeilen 65–70: die Dialogschleife. Sie hat dieselbe Struktur wie die des Servers: [stream_select] wartet darauf, dass der Server oder die Tastatur etwas sendet. Ist die Standardeingabe zu Ende (wie bei in eine Datei umgeleiteter Eingabe), zeigt der Client weiterhin an, was der Server sendet, wartet aber nicht länger als 2 Sekunden darauf;
- Zeilen 73–85: Die vom Server gesendeten Zeilen werden in eckigen Klammern angezeigt und in die Protokolldatei geschrieben. Schließt der Server die Verbindung, endet die Schleife;
- Zeilen 88–108: Jede über die Tastatur eingegebene Zeile wird an den Server gesendet, gefolgt von der Sequenz \r\n, mit Ausnahme des Stoppbefehls des Clients;
- Zeile 115: Schließlich wird der Kindprozess beendet, der die Tastatur liest.
16.2.2.4. Ein Beispiel
Sehen wir uns ein Beispiel an. Öffnen Sie zwei Terminals (in VS Code öffnet die Schaltfläche [+] in der Ansicht [Terminal] ein neues) und wechseln Sie in beiden in den Ordner [inet/utilities]. Starten Sie im ersten Terminal den Server auf Port 100. Starten Sie im zweiten den Client und weisen Sie ihn an, sich mit Port 100 des lokalen Rechners [localhost] zu verbinden, und geben Sie dann eine Textzeile ein. Wechseln Sie zurück zum Server, antworten Sie Client Nr. 1, fordern Sie die Liste der Clients an, schließen Sie die Verbindung zu Client Nr. 1 und beenden Sie den Server.
Hier sehen Sie, was der Server anzeigt (die über die Tastatur eingegebenen Befehle sind die Zeilen [send 1 ...], [list], [close 1], und [quit]):
| > php tcp-server.php 100
Server listening on the port [100]
Commands: list, send id [text], close id, quit
Client no. 1 [127.0.0.1:47966] connected
<-- client no. 1 [hello from client]
send 1 [hello from server]
list
id=1 - name=127.0.0.1:47966
close 1
Connection with the client no. 1 closed
quit
Server stopped
|
- [Client no. 1 [127.0.0.1:47966] connected]: Ein Client wurde erkannt. Der Server hat ihm die Nummer 1 zugewiesen. Der Client verwendet Port 47966 auf dem Rechner mit der IP-Adresse 127.0.0.1. Diese Adresse gehört zu [localhost], dem lokalen Rechner;
- [<-- client no. 1 [hello from client]]: Die vom Client empfangene Zeile steht in eckigen Klammern;
- [send 1 [hello from server]]: die an Client Nr. 1 gesendete Antwort. Nur der Text innerhalb der eckigen Klammern wird gesendet, nicht die Klammern selbst;
- [list]: die Liste der Clients und die Antwort darauf;
- [close 1] gefolgt von [quit]: Die Verbindung zu Client Nr. 1 wird geschlossen, dann wird der Server heruntergefahren.
Und hier sehen Sie, was der Client anzeigt:
| > php tcp-client.php localhost 100
Client [127.0.0.1:47966] connected to the server [localhost:100]
Type your commands (quit to stop):
hello from client
<-- [hello from server]
Connection with the server lost...
End of the client
|
- [hello from client]: die über die Tastatur eingegebene Zeile;
- [<-- [hello from server]]: die vom Server empfangene Antwort. Der empfangene Text ist der in eckigen Klammern;
- [Connection with the server lost...]: Der Client hat erkannt, dass der Server die Verbindung geschlossen hat.
Es wurden zwei Protokolldateien im Ordner [utilities/logs] erstellt, eine vom Server und eine vom Client. Die Serverdatei ist nach dem Client benannt, [127.0.0.1-47966.txt]:
| <-- [hello from client]
--> [hello from server]
|
Die Clientdatei ist nach dem Server benannt, [localhost-100.txt]:
| --> [hello from client]
<-- [hello from server]
|
16.3. Namen oder IP-Adresse eines Rechners im Internet ermitteln
Computer im Internet werden durch eine Adresse (IP, IPv4 oder IPv6) und meist durch einen Namen identifiziert. Letztlich wird jedoch nur die Adresse verwendet. Daher muss man manchmal die IP-Adresse eines Rechners kennen, der durch seinen Namen identifiziert ist. Das ist die Aufgabe des DNS-Dienstes (Domain Name System).
Das Skript [inet/ip/ip-01.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// IP-Adressen und Rechnernamen des Internets
// die Rechner, deren IP-Adresse und Namen wir wissen wollen
const HOSTS = ["istia.univ-angers.fr", "www.univ-angers.fr", "www.ibm.com", "www.php.net", "yahoo.com", "localhost", "xx"];
// wir fügen den lokalen Rechner hinzu, dessen Name von [gethostname] geliefert wird
foreach ([...HOSTS, gethostname()] as $host) {
getIPandName($host);
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function getIPandName(string $machineName): void
{
// $machineName: Name des Rechners, dessen IP-Adresse wir wissen wollen
print "---------------\n";
// machineName --> IP-Adresse
$ip = gethostbyname($machineName);
if ($ip === $machineName) {
print "Error, machine [$machineName] not found\n";
return;
}
print "ip[$machineName]=$ip\n";
// alle IPv4-Adressen des Rechners
$ips = gethostbynamel($machineName);
if ($ips !== false && count($ips) > 1) {
print "all the IPv4 addresses of [$machineName]: " . implode(", ", $ips) . "\n";
}
// IP-Adresse --> machineName
$name = gethostbyaddr($ip);
if ($name === false || $name === $ip) {
print "Error, no name for the address [$ip]\n";
} else {
print "name[$ip]=$name\n";
}
}
|
Kommentare:
- Zeile 8: die Liste der Rechner, deren Namen und IP-Adresse wir ermitteln möchten;
- Zeile 11: Der Name des lokalen Rechners, den die Funktion [gethostname] liefert, wird dieser Liste hinzugefügt. Der Operator [...] kopiert die Elemente des Arrays [HOSTS] in das neue Array;
- Zeile 18: Die Netzwerkfunktionen von PHP werden in der Funktion [getIPandName] verwendet;
- Zeile 23: Die Funktion [gethostbyname($machineName)] liefert die IPv4-Adresse "ip3.ip2.ip1.ip0" des Rechners namens $machineName. Existiert der Rechner $machineName nicht, gibt die Funktion $machineName als Ergebnis zurück;
- Zeile 30: Ein Rechner kann mehrere Adressen haben, etwa IPv4. Die Funktion [gethostbynamel] liefert sie alle in einem Array (oder [false] , wenn die Operation fehlschlägt);
- Zeile 35: Die Funktion [gethostbyaddr($ip)] ermittelt den Namen des Rechners mit der Adresse $ip. Hat die Adresse $ip keinen Namen, gibt die Funktion $ip als Ergebnis zurück, und [false] , wenn die Adresse fehlerhaft aufgebaut ist.
Die Funktionen [gethostbyname] und [gethostbynamel] erkennen nur Adressen der Form IPv4. Um die IPv6-Adressen eines Rechners zu erhalten, würden Sie die Funktion [dns_get_record] mit dem Typ [DNS_AAAA] verwenden.
Ergebnisse:
| > php ip-01.php
---------------
ip[istia.univ-angers.fr]=193.49.144.41
name[193.49.144.41]=ametys-fo-2.univ-angers.fr
---------------
ip[www.univ-angers.fr]=193.49.144.41
name[193.49.144.41]=ametys-fo-2.univ-angers.fr
---------------
ip[www.ibm.com]=23.217.77.36
name[23.217.77.36]=a23-217-77-36.deploy.static.akamaitechnologies.com
---------------
ip[www.php.net]=107.150.176.1
name[107.150.176.1]=107-150-176-1.bunnyinfra.net
---------------
ip[yahoo.com]=98.137.11.163
all the IPv4 addresses of [yahoo.com]: 98.137.11.164, 98.137.11.163, 74.6.231.21, 74.6.143.25, 74.6.231.20, 74.6.143.26
name[98.137.11.163]=media-router-fp74.prod.media.vip.gq1.yahoo.com
---------------
ip[localhost]=127.0.0.1
name[127.0.0.1]=localhost
---------------
Error, machine [xx] not found
---------------
ip[vm]=127.0.0.1
name[127.0.0.1]=localhost
Done
|
- Die Rechner [istia.univ-angers.fr] und [www.univ-angers.fr] haben dieselbe IP-Adresse. Der aus der IP-Adresse ermittelte Name – der sogenannte kanonische Name – ist noch ein anderer Name;
- Der Name [www.ibm.com] ist einem Server von Akamai zugeordnet, einem Unternehmen, das die Websites vieler Firmen hostet;
- Der Rechner [yahoo.com] hat sechs IPv4-Adressen: Anfragen werden auf mehrere Server verteilt;
- [localhost] hat die Adresse 127.0.0.1, die sogenannte Loopback-Adresse: Sie bezeichnet immer den lokalen Rechner;
- Der Rechner [xx] existiert nicht;
- der letzte Rechner ist der lokale Rechner, hier mit dem Namen [vm] bezeichnet. Die Ergebnisse hängen von der Konfiguration des Rechners ab: Auf einem Windows-Computer erhalten Sie den Namen Ihres Computers und, je nach Konfiguration, seine Adresse im lokalen Netzwerk (zum Beispiel 192.168.x.y).
Die Ergebnisse, die man für Rechner im Internet erhält, ändern sich mit der Zeit: Sie werden wahrscheinlich nicht dieselben Ergebnisse erhalten.
16.4. Das HTTP-Protokoll (HyperText Transfer Protocol)
16.4.1. Beispiel 1

Wenn ein Browser eine URL anzeigt, agiert er als Client eines Webservers – mit anderen Worten eines HTTP-Servers. Der Browser ergreift die Initiative und sendet zunächst eine Reihe von Befehlen an den Server. Für dieses erste Beispiel gilt:
- der Server ist das Dienstprogramm [tcp-server.php];
- der Client ist ein Webbrowser.
Zuerst starten wir den Server auf Port 100 und fordern dann mit einem Browser die URL [http://localhost:100] an; damit teilen wir mit, dass der abgefragte HTTP-Server auf Port 100 des lokalen Rechners läuft. Der Browser wartet auf die Antwort. Kehren wir zum Serverfenster zurück. Dort sehen wir die vom Browser gesendeten Zeilen. Anschließend tippen wir Zeile für Zeile eine Antwort im HTTP-Format ein, schließen dann die Verbindung und beenden den Server:
| > php tcp-server.php 100
Server listening on the port [100]
Commands: list, send id [text], close id, quit
Client no. 1 [127.0.0.1:45752] connected
<-- client no. 1 [GET / HTTP/1.1]
<-- client no. 1 [Host: localhost:100]
<-- client no. 1 [Connection: keep-alive]
<-- client no. 1 [sec-ch-ua: "HeadlessChrome";v="141", "Not?A_Brand";v="8", "Chromium";v="141"]
<-- client no. 1 [sec-ch-ua-mobile: ?0]
<-- client no. 1 [sec-ch-ua-platform: "Linux"]
<-- client no. 1 [Upgrade-Insecure-Requests: 1]
<-- client no. 1 [User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/141.0.7390.37 Safari/537.36]
<-- client no. 1 [Accept-Language: en-US]
<-- client no. 1 [Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7]
<-- client no. 1 [Sec-Fetch-Site: none]
<-- client no. 1 [Sec-Fetch-Mode: navigate]
<-- client no. 1 [Sec-Fetch-User: ?1]
<-- client no. 1 [Sec-Fetch-Dest: document]
<-- client no. 1 [Accept-Encoding: gzip, deflate, br, zstd]
<-- client no. 1 []
send 1 [HTTP/1.1 200 OK]
send 1 [Content-Type: text/html; charset=utf-8]
send 1 [Connection: close]
send 1 []
send 1 [<h1>Hello from the TCP server!</h1>]
close 1
Connection with the client no. 1 closed
list
quit
Server stopped
|
- [Client no. 1]: der Browser, der sich verbunden hat;
- gefolgt von den Textzeilen, die er gesendet hat:
- [GET / HTTP/1.1]: Diese Zeile hat das Format [GET URL HTTP/1.1]. Sie fordert die URL / an und weist den Server an, das HTTP-1.1-Protokoll zu verwenden;
- [Host: localhost:100]: Diese Zeile hat das Format [Host: server:port]. Die Groß- und Kleinschreibung des Headers [Host] spielt keine Rolle. Beachten Sie, dass der Client einen lokalen Server abfragt, der auf Port 100 läuft;
- der Header [Connection] legt den gewünschten Verbindungsmodus fest: [keep-alive] bedeutet, dass die Verbindung nach der Antwort für etwaige weitere Anfragen aufrechterhalten werden muss;
- der Header [User-Agent] gibt die Identität des Clients an. In diesem Fall handelt es sich um einen Chromium-Browser. Die Header [sec-ch-ua...] und [Sec-Fetch...] sind spezifisch für neuere Browser. Die genauen Werte hängen vom verwendeten Browser und Betriebssystem ab;
- Der Header [Accept] legt fest, welche Dokumenttypen der Client akzeptiert;
- der Header [Accept-Language] legt die bevorzugte Sprache der angeforderten Dokumente fest, falls sie in mehreren Sprachen verfügbar sind;
- Der Header [Accept-Encoding] zeigt an, dass der Client komprimierte Dokumente akzeptiert;
- der Client beendet seine Befehle mit einer Leerzeile;
- Die Befehle [send 1 [...]] senden die Antwort an den Browser: eine erste Zeile [HTTP/1.1 200 OK], die anzeigt, dass das angeforderte Dokument gefunden wurde; Header; eine Leerzeile; und danach das Dokument. Der Header [Content-Type] legt den Dokumenttyp fest – hier HTML in UTF-8-Kodierung –, und der Header [Connection: close] zeigt an, dass der Server die Verbindung am Ende des Dokuments schließt;
- [close 1]: Das Schließen der Verbindung signalisiert dem Browser, dass das Dokument vollständig ist.
Der Browser zeigt anschließend das empfangene Dokument an:

Wir haben soeben einen Webserver „von Grund auf“ geschrieben!
16.4.2. Beispiel 2
Nachdem wir nun die Befehle kennen, die ein Browser zum Anfordern einer URL sendet, fordern wir eine URL mit unserem TCP-Client [tcp-client.php] an. Der Apache-Server von [Laragon] wird unser Webserver sein: Starten Sie ihn (die Schaltfläche [Start All] in [Laragon]). Der Ordner [inet/http/pages] enthält eine statische HTML-Seite:
| <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello</title>
</head>
<body>
<h1>Hello!</h1>
<p>A static page served by the web server.</p>
</body>
</html>
|
Da sich das Verzeichnis [php8-oct-2026] innerhalb des Verzeichnisses [<laragon>/www] befindet, ist diese Seite über die URL [http://localhost/php8-oct-2026/scripts-console/inet/http/pages/hello.html] erreichbar. Fordern wir sie mit unserem TCP-Client an, der mit Port 80 des Servers [localhost] verbunden ist, auf dem der Webserver läuft. Wir geben die Befehle ein, die wir im vorigen Abschnitt kennengelernt haben:
| > php tcp-client.php localhost 80
Client [127.0.0.1:59734] connected to the server [localhost:80]
Type your commands (quit to stop):
GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
Host: localhost:80
<-- [HTTP/1.1 200 OK]
<-- [Date: Thu, 01 Oct 2026 15:32:51 GMT]
<-- [Server: Apache/2.4.58 (Ubuntu)]
<-- [Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT]
<-- [ETag: "e2-65cc8b40e550d"]
<-- [Accept-Ranges: bytes]
<-- [Content-Length: 226]
<-- [Vary: Accept-Encoding]
<-- [Content-Type: text/html]
<-- []
<-- [<!DOCTYPE html>]
<-- [<html lang="en">]
<-- [ <head>]
<-- [ <meta charset="utf-8">]
<-- [ <title>Hello</title>]
<-- [ </head>]
<-- [ <body>]
<-- [ <h1>Hello!</h1>]
<-- [ <p>A static page served by the web server.</p>]
<-- [ </body>]
<-- [</html>]
quit
End of the client
|
- [GET ... HTTP/1.1]: der Befehl [GET] mit dem Pfad des angeforderten Dokuments;
- [Host: localhost:80]: der Header [Host];
- dies sind die einzigen beiden unverzichtbaren Befehle. Für die übrigen Header verwendet der Webserver Standardwerte;
- die Leerzeile, die die Befehle des Clients abschließen muss;
- Unterhalb der Leerzeile folgt die Antwort des Apache-Webservers:
- [HTTP/1.1 200 OK]: die Statuszeile. Der Code 200 bedeutet, dass das Dokument gefunden wurde;
- danach folgen die HTTP-Antwort-Header, gefolgt von einer Leerzeile. Der Header [Content-Length] gibt die Größe des Dokuments in Byte an;
- nach der Leerzeile folgt das angeforderte HTML-Dokument;
- der Header [Server] identifiziert den Webserver: in diesem Fall einen Apache-2.4-Server. Mit [Laragon] sehen Sie den Eintrag [(Win64)] und die Versionen von OpenSSL und PHP;
- [quit]: Wir geben [quit] ein, um die Client-Verbindung zu beenden. Der Server hält die Verbindung hingegen noch einige Sekunden offen (HTTP/1.1-Keep-Alive-Modus), während er auf eine weitere Anfrage wartet, und schließt sie dann.
Die Protokolldatei [utilities/logs/localhost-80.txt] enthält die Austauschvorgänge:
| --> [GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1]
--> [Host: localhost:80]
--> []
<-- [HTTP/1.1 200 OK]
<-- [Date: Thu, 01 Oct 2026 15:32:51 GMT]
<-- [Server: Apache/2.4.58 (Ubuntu)]
<-- [Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT]
<-- [ETag: "e2-65cc8b40e550d"]
<-- [Accept-Ranges: bytes]
<-- [Content-Length: 226]
<-- [Vary: Accept-Encoding]
<-- [Content-Type: text/html]
<-- []
<-- [<!DOCTYPE html>]
<-- [<html lang="en">]
<-- [ <head>]
<-- [ <meta charset="utf-8">]
<-- [ <title>Hello</title>]
<-- [ </head>]
<-- [ <body>]
<-- [ <h1>Hello!</h1>]
<-- [ <p>A static page served by the web server.</p>]
<-- [ </body>]
<-- [</html>]
|
Damit haben wir die Grundlagen, um einen TCP-Client zu programmieren, der eine URL anfordert.
16.4.3. Beispiel 3

Das Skript [inet/http/http-01.php] ist ein HTTP-Client, der durch die JSON-Datei [config-http-01.json] konfiguriert wird. Deren Inhalt ist wie folgt:
| {
"localhost": {
"port": 80,
"GET": "/php8-oct-2026/scripts-console/inet/http/pages/hello.html",
"Host": "localhost:80",
"User-Agent": "client PHP",
"Accept": "text/html",
"Accept-Language": "en",
"Connection": "close",
"endOfLine": "\r\n"
}
}
|
- Zeile 2: der Name des Rechners, der den anzusprechenden Webserver hostet;
- Zeile 3: der Port, auf dem dieser Webserver arbeitet;
- Zeile 4: die URL des gewünschten Dokuments;
- Zeile 5: der Zielrechner im Format Rechner:Port;
- Zeile 6: die HTTP-Client-Kennung: Sie können eintragen, was Sie möchten;
- Zeile 7: der vom Client akzeptierte Dokumenttyp, hier HTML-Text;
- Zeile 8: die gewünschte Sprache des angeforderten Dokuments;
- Zeile 9: Der Server wird angewiesen, die Verbindung zu schließen, sobald das Dokument gesendet wurde. Ohne diesen Header hält ein HTTP/1.1-Server die Verbindung einige Sekunden offen, während er auf eine weitere Anfrage wartet, und unser Client – der bis zum Schließen der Verbindung liest – würde unnötig warten;
- Zeile 10: das Zeilenendezeichen für die vom Client gesendeten Befehle. Das HTTP-Protokoll verlangt die Sequenz \r\n.
Das Skript [http-01.php] sieht wie folgt aus:
| <?php
declare(strict_types=1);
// einfacher HTTP-Client: fordert ein Dokument von einem Webserver an und speichert es in einer Datei
// die Konfigurationsdatei kann als Argument übergeben werden (php http-01.php config.json)
$configFileName = $argv[1] ?? "config-http-01.json";
// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents($configFileName), true);
// den HTML-Text der URLs der Konfigurationsdatei abrufen
foreach ($config as $site => $protocol) {
// Lesen der URL der Site $site
$result = getURL($site, $protocol);
// Ergebnisanzeige
print "$result\n";
}
// --------------------------------------------------------------------------
function getURL(string $site, array $protocol, bool $tracking = true): string
{
// liest die URL $protocol["GET"] der Site $site und speichert sie in der Datei output/$site.html
// der Dialog zwischen Client und Server folgt dem Protokoll $protocol
//
// Öffnen einer Verbindung am Port $protocol["port"] von $site
$connection = @stream_socket_client("tcp://$site:{$protocol["port"]}", $errorNumber, $error, 10);
// Rückkehr bei Fehler
if ($connection === false) {
return "Failed to connect to the site [$site:{$protocol["port"]}]: $error";
}
// $connection stellt einen bidirektionalen Kommunikationsstrom
// zwischen dem Client (diesem Programm) und dem kontaktierten Webserver dar
// dieser Kanal dient dem Austausch von Befehlen und Informationen
// das Dialogprotokoll ist HTTP
//
// Erzeugen der Datei output/$site.html
if (!is_dir("output")) {
mkdir("output");
}
$html = fopen("output/$site.html", "w");
if ($html === false) {
fclose($connection);
return "Error while creating the file [output/$site.html]";
}
// der Client wird den HTTP-Dialog mit dem Server beginnen
if ($tracking) {
print "Client: start of the communication with the server [$site] ----------------------------\n";
}
// die vom Client gesendeten Zeilen müssen mit \r\n enden
$endOfLine = $protocol["endOfLine"];
// der Einfachheit halber werden Fehlerfälle in der Client-Server-Kommunikation nicht getestet
// der Client sendet den Befehl GET, um die URL $protocol["GET"] anzufordern
// Syntax GET URL HTTP/1.1
$command = "GET {$protocol["GET"]} HTTP/1.1$endOfLine";
if ($tracking) {
print "--> $command";
}
fwrite($connection, $command);
// Senden der übrigen HTTP-Header
foreach ($protocol as $verb => $value) {
if (!in_array($verb, ["GET", "port", "endOfLine"], true)) {
// wir bauen den Befehl zusammen
$command = "$verb: $value$endOfLine";
if ($tracking) {
print "--> $command";
}
// wir senden den Befehl an den Server
fwrite($connection, $command);
}
}
// die Header des HTTP-Protokolls müssen mit einer Leerzeile enden
fwrite($connection, $endOfLine);
//
// der Server wird nun auf dem Kanal $connection antworten. Er sendet alle
// seine Daten und schließt dann den Kanal (Connection: close). Der Client liest also alles,
// was von $connection kommt, bis der Kanal geschlossen wird
//
// wir lesen zuerst die vom Server gesendeten HTTP-Header
// sie enden ebenfalls mit einer Leerzeile
if ($tracking) {
print "Response of the server [$site] ----------------------------\n";
}
while (($line = fgets($connection)) !== false) {
// wir entfernen die Leerraumzeichen am Zeilenende (einschließlich \r\n)
$line = rtrim($line);
// haben wir die Leerzeile, die die Header beendet?
if ($line === "") {
break;
}
// wir zeigen den HTTP-Header an
if ($tracking) {
print "<-- $line\n";
}
}
// wir lesen das HTML-Dokument, das auf die Leerzeile folgt, und speichern es in der Datei
while (($line = fgets($connection)) !== false) {
fwrite($html, $line);
}
// der Server hat die Verbindung geschlossen - der Client schließt sie seinerseits
fclose($connection);
fclose($html);
// Rückkehr
return "End of the communication with the site [$site]. Check the file [output/$site.html]";
}
|
Hinweise zum Code:
- Zeile 7: Die Konfigurationsdatei kann als Argument übergeben werden. Wir werden mehrere Konfigurationsdateien verwenden;
- Zeile 10: Aus der Konfigurationsdatei wird ein Dictionary erstellt:
- Die Schlüssel des Dictionarys sind die abzufragenden Webserver;
- die Werte legen das zu verwendende HTTP-Protokoll fest;
- Zeile 12: Das Programm durchläuft die Liste der Webserver aus der Konfiguration;
- Zeile 20: Die Funktion [getURL($site, $protocol, $tracking)] fordert ein Dokument von der Website $site an und speichert es in der Textdatei [output/$site.html]. Standardmäßig werden die Austauschvorgänge zwischen Client und Server auf der Konsole angezeigt ($tracking=true);
- Zeile 26: Die Funktion [stream_socket_client] baut eine Verbindung zu einem TCP/IP-Dienst auf, der auf dem Port [port] des Rechners $site läuft. Sobald die Verbindung zwischen Client und Server steht, tauschen viele TCP/IP-Dienste Textzeilen aus. So verhält es sich hier beim HTTP-Protokoll. Der Datenstrom vom Server zum Client kann dann wie eine Textdatei behandelt und mit [fgets] gelesen werden. Dasselbe gilt für den Datenstrom vom Client zum Server, der mit [fwrite] geschrieben werden kann;
- Zeile 40: Erstellung der Datei [output/$site.html], in der das empfangene HTML-Dokument gespeichert wird;
- Zeile 54: Der erste Befehl des Clients muss [GET URL HTTP/1.1] lauten. Er bedeutet: „Ich möchte (GET) die Seite [URL] der Website abrufen, mit der ich verbunden bin. Ich verwende das HTTP-Protokoll in Version 1.1“;
- Zeilen 60–70: Die übrigen Zeilen des HTTP-Protokolls [Host, User-Agent, Accept, Accept-Language, Connection] werden gesendet. Ihre Reihenfolge spielt keine Rolle. Im PHP-7-Kurs wurden die Schlüssel getestet, um sie einzeln auszuschließen; die Funktion [in_array] mit dem dritten Parameter [true] (strikter Vergleich) ist besser lesbar;
- Zeile 72: Es wird eine leere Zeile an den Server gesendet, um anzuzeigen, dass der Client das Senden seiner HTTP-Header beendet hat und nun auf das angeforderte Dokument wartet;
- Zeilen 83–94: Der Server sendet zunächst eine Reihe von HTTP-Headern, die verschiedene Details zum angeforderten Dokument liefern. Diese Header enden mit einer Leerzeile. Wir lesen eine Zeile mit [fgets], entfernen die nachgestellten Leerzeichen (einschließlich \r\n) mit [rtrim] und prüfen, ob es sich um die Leerzeile handelt, die das Ende der Header markiert. Falls nicht, wird der Header angezeigt;
- Zeilen 95–97: Die Textzeilen des Dokuments können mit einer while-Schleife Zeile für Zeile gelesen und in der Textdatei [output/$site.html] gespeichert werden. Sobald der Webserver das gesamte Dokument gesendet hat, schließt er seine Verbindung zum Client. Auf der Client-Seite wird dies als Dateiende erkannt: [fgets] liefert dann [false].
Führen wir das Skript in einem Terminal aus, das im Ordner [inet/http] geöffnet ist. Die Konsole zeigt die folgenden Protokolle an:
| > php http-01.php
Client: start of the communication with the server [localhost] ----------------------------
--> GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
--> Host: localhost:80
--> User-Agent: client PHP
--> Accept: text/html
--> Accept-Language: en
--> Connection: close
Response of the server [localhost] ----------------------------
<-- HTTP/1.1 200 OK
<-- Date: Thu, 01 Oct 2026 16:47:43 GMT
<-- Server: Apache/2.4.58 (Ubuntu)
<-- Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT
<-- ETag: "e2-65cc8b40e550d"
<-- Accept-Ranges: bytes
<-- Content-Length: 226
<-- Vary: Accept-Encoding
<-- Connection: close
<-- Content-Type: text/html
End of the communication with the site [localhost]. Check the file [output/localhost.html]
|
In unserem Beispiel sieht die empfangene Datei [output/localhost.html] wie folgt aus:
| <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello</title>
</head>
<body>
<h1>Hello!</h1>
<p>A static page served by the web server.</p>
</body>
</html>
|
Dies ist tatsächlich das Dokument [hello.html]: Es ist auch dasjenige, das ein Browser anzeigt.
16.4.4. Beispiel 4
In diesem Beispiel zeigen wir, dass der von uns geschriebene HTTP-Client unzureichend ist.
16.4.4.1. Das HTTPS-Protokoll
Passen wir die Konfigurationsdatei an. Die Datei [config-http-01-https.json] sieht wie folgt aus:
| {
"localhost": {
"port": 443,
"GET": "/php8-oct-2026/scripts-console/inet/http/pages/hello.html",
"Host": "localhost:443",
"User-Agent": "client PHP",
"Accept": "text/html",
"Accept-Language": "en",
"Connection": "close",
"endOfLine": "\r\n"
}
}
|
Hier fordern wir das Dokument [hello.html] über Port 443 des Servers [localhost] an. Port 443 ist der Port des sicheren HTTP-Protokolls, bekannt als HTTPS. Bei diesem Protokoll beginnt der Dialog zwischen Client und Server mit einem Informationsaustausch, der die Verbindung absichert: Sie wird durch das TLS-Protokoll verschlüsselt. Der Client muss daher das HTTPS-Protokoll statt des HTTP-Protokolls verwenden, was unser Client nicht tut.
Der Apache-Server von [Laragon] unterstützt das HTTPS-Protokoll, es ist aber standardmäßig nicht aktiviert. Die Aktivierung erfolgt über das Menü von [Laragon]: Klicken Sie mit der rechten Maustaste in das Fenster von [Laragon] und wählen Sie dann [Apache / SSL / Enabled]. Der Apache-Server wird daraufhin neu gestartet und lauscht nun auf zwei Ports: Port 80 (HTTP) und Port 443 (HTTPS). [Laragon] hat dafür ein sogenanntes selbstsigniertes Zertifikat erzeugt. Auf diesen Punkt kommen wir im nächsten Kapitel zurück.
Mit dieser Konfigurationsdatei ([php http-01.php config-http-01-https.json]) lautet die Konsolenausgabe wie folgt:
| > php http-01.php config-http-01-https.json
Client: start of the communication with the server [localhost] ----------------------------
--> GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
--> Host: localhost:443
--> User-Agent: client PHP
--> Accept: text/html
--> Accept-Language: en
--> Connection: close
Response of the server [localhost] ----------------------------
<-- HTTP/1.1 400 Bad Request
<-- Date: Thu, 01 Oct 2026 16:47:43 GMT
<-- Server: Apache/2.4.58 (Ubuntu)
<-- Content-Length: 438
<-- Connection: close
<-- Content-Type: text/html; charset=iso-8859-1
End of the communication with the site [localhost]. Check the file [output/localhost.html]
|
- [HTTP/1.1 400 Bad Request]: Der Server hat geantwortet, dass die Anfrage des Clients ungültig war.
Der Inhalt der Datei [output/localhost.html] lautet wie folgt:
| <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
Reason: You're speaking plain HTTP to an SSL-enabled server port.<br />
Instead use the HTTPS scheme to access this URL, please.<br />
</p>
<hr>
<address>Apache/2.4.58 (Ubuntu) Server at 127.0.0.1 Port 443</address>
</body></html>
|
Der Server weist deutlich darauf hin, dass wir nicht das richtige Protokoll verwendet haben: „You’re speaking plain HTTP to an SSL-enabled server port“ (Sie sprechen HTTP mit einem Port, der für SSL reserviert ist, den früheren Namen von TLS).
16.4.4.2. In Teilen (Chunks) gesendetes Dokument
Der Ordner [inet/http/pages] enthält ein zweites Dokument, das PHP-Skript [index.php]:
| <?php
declare(strict_types=1);
// eine in mehreren Teilen gesendete Seite: [flush] erzwingt das sofortige Senden des bereits Geschriebenen
// der Server kennt die Gesamtgröße des Dokuments daher nicht, wenn er die Header sendet
print "<!DOCTYPE html>\n<html lang=\"en\">\n<head><meta charset=\"utf-8\"><title>Chunks</title></head>\n<body>\n";
flush();
for ($i = 1; $i <= 3; $i++) {
print "<p>chunk no. $i</p>\n";
flush();
}
print "</body>\n</html>\n";
|
- Zeile 8: Die Funktion [flush] weist den Server an, alles, was das Skript bereits geschrieben hat, sofort an den Client zu senden. Dadurch sendet das Skript sein Dokument in fünf getrennten Teilen. Beim Senden der HTTP-Antwort-Header kennt der Server daher die Gesamtgröße des Dokuments nicht.
Verwenden wir nun die folgende Konfigurationsdatei [config-http-01-chunks.json]:
| {
"localhost": {
"port": 80,
"GET": "/php8-oct-2026/scripts-console/inet/http/pages/",
"Host": "localhost:80",
"User-Agent": "client PHP",
"Accept": "text/html",
"Accept-Language": "en",
"Connection": "close",
"endOfLine": "\r\n"
}
}
|
- Zeile 4: Wir fordern die Datei [pages/] an. Der Apache-Server sendet dann sein Standarddokument, in diesem Fall [index.php].
Die Konsolenausgabe lautet wie folgt:
| > php http-01.php config-http-01-chunks.json
Client: start of the communication with the server [localhost] ----------------------------
--> GET /php8-oct-2026/scripts-console/inet/http/pages/ HTTP/1.1
--> Host: localhost:80
--> User-Agent: client PHP
--> Accept: text/html
--> Accept-Language: en
--> Connection: close
Response of the server [localhost] ----------------------------
<-- HTTP/1.1 200 OK
<-- Date: Thu, 01 Oct 2026 16:47:43 GMT
<-- Server: Apache/2.4.58 (Ubuntu)
<-- X-Powered-By: PHP/8.5.11
<-- Vary: Accept-Encoding
<-- Connection: close
<-- Transfer-Encoding: chunked
<-- Content-Type: text/html; charset=UTF-8
End of the communication with the site [localhost]. Check the file [output/localhost.html]
|
- Der Header [X-Powered-By] zeigt an, dass das Dokument von PHP 8.5 erzeugt wurde;
- der Header [Transfer-Encoding: chunked] zeigt an, dass der Server das Dokument in Teilen sendet. Es gibt keinen Header [Content-Length]: Der Server kündigt die Größe des Dokuments nicht an.
Daraus ergibt sich, dass im an den Client gesendeten Datenstrom Zahlen auftauchen: Jedem Chunk geht eine Zeile voraus, die seine Größe hexadezimal angibt, und das Dokument endet mit einem Chunk der Größe 0. Hier ist die Datei [output/localhost.html]:
| 61
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Chunks</title></head>
<body>
13
<p>chunk no. 1</p>
13
<p>chunk no. 2</p>
13
<p>chunk no. 3</p>
10
</body>
</html>
0
|
- [61]: die hexadezimale Größe des ersten Chunks, also 97 Byte: die ersten vier Zeilen des Dokuments;
- [13]: die Größe der nächsten drei Chunks, also 19 Byte;
- [10]: die Größe des letzten Chunks, 16 Byte;
- [0]: der 0-Byte-Chunk, der das Dokument abschließt.
Ein ordentlicher HTTP-Client sollte diese Zahlen nicht im endgültigen Dokument belassen.
16.4.4.3. Weiterleitung
Hier ist eine letzte Konfigurationsdatei, [config-http-01-redirect.json]:
| {
"localhost": {
"port": 80,
"GET": "/php8-oct-2026/scripts-console/inet/http/pages",
"Host": "localhost:80",
"User-Agent": "client PHP",
"Accept": "text/html",
"Accept-Language": "en",
"Connection": "close",
"endOfLine": "\r\n"
}
}
|
Sie ähnelt dem vorigen Beispiel, aber die angeforderte URL endet nicht mit einem /-Zeichen. Es handelt sich nicht um dieselbe URL. Die Ausführung des HTTP-Clients erzeugt dann die folgende Konsolenausgabe:
| > php http-01.php config-http-01-redirect.json
Client: start of the communication with the server [localhost] ----------------------------
--> GET /php8-oct-2026/scripts-console/inet/http/pages HTTP/1.1
--> Host: localhost:80
--> User-Agent: client PHP
--> Accept: text/html
--> Accept-Language: en
--> Connection: close
Response of the server [localhost] ----------------------------
<-- HTTP/1.1 301 Moved Permanently
<-- Date: Thu, 01 Oct 2026 16:47:43 GMT
<-- Server: Apache/2.4.58 (Ubuntu)
<-- Location: http://localhost/php8-oct-2026/scripts-console/inet/http/pages/
<-- Content-Length: 346
<-- Connection: close
<-- Content-Type: text/html; charset=iso-8859-1
End of the communication with the site [localhost]. Check the file [output/localhost.html]
|
- [HTTP/1.1 301 Moved Permanently]: Der Code 301 zeigt an, dass das angeforderte Dokument dauerhaft unter eine andere URL verschoben wurde;
- [Location: ...]: die neue URL. Beachten Sie diesmal das /-Zeichen am Ende: [pages] ist ein Verzeichnis, und der Apache-Server weist den Client an, es als URL mit abschließendem / anzusprechen.
Die Datei [output/localhost.html] sieht dann wie folgt aus:
| <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>301 Moved Permanently</title>
</head><body>
<h1>Moved Permanently</h1>
<p>The document has moved <a href="http://localhost/php8-oct-2026/scripts-console/inet/http/pages/">here</a>.</p>
<hr>
<address>Apache/2.4.58 (Ubuntu) Server at localhost Port 80</address>
</body></html>
|
Ein HTTP-Client sollte Weiterleitungen folgen können. In diesem Fall sollte er automatisch die neue URL [http://localhost/php8-oct-2026/scripts-console/inet/http/pages/] anfordern.
16.4.5. Beispiel 5
Die vorherigen Beispiele haben uns gezeigt, dass unser HTTP-Client unzureichend war. Wir führen nun ein Werkzeug namens [curl] ein, mit dem sich Webdokumente abrufen lassen und das die genannten Probleme behandelt: das HTTPS-Protokoll, in Teilen gesendete Dokumente, Weiterleitungen … Das Werkzeug [curl] ist in Windows (ab Windows 10) und in [Laragon] enthalten. In einem PowerShell-Terminal müssen Sie [curl.exe] eingeben, nicht [curl]: In PowerShell 5 ist [curl] ein Alias für einen anderen Befehl, nämlich [Invoke-WebRequest].
Der Befehl [curl --help] zeigt die wichtigsten Konfigurationsoptionen von [curl] an. Es gibt davon mehrere Dutzend. Wir werden nur sehr wenige davon verwenden. Um eine URL anzufordern, genügt der Befehl [curl URL]. Dieser Befehl zeigt das angeforderte Dokument auf der Konsole an. Wenn Sie zusätzlich die HTTP-Austauschvorgänge zwischen Client und Server sehen möchten, geben Sie [curl --verbose URL] ein. Um das angeforderte HTML-Dokument schließlich in einer Datei zu speichern, geben Sie [curl --verbose --output file URL] ein.
Um die Kursordner nicht zu überladen, wechseln wir in einen Arbeitsordner – zum Beispiel [c:\temp\curl] (legen Sie ihn an, falls er nicht existiert) – und fordern die Seite [hello.html] an:
| > curl --verbose --output localhost.html http://localhost/php8-oct-2026/scripts-console/inet/http/pages/hello.html
* Host localhost:80 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0* Trying 127.0.0.1:80...
* Connected to localhost (127.0.0.1) port 80
> GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
> Host: localhost
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Date: Thu, 01 Oct 2026 15:32:56 GMT
< Server: Apache/2.4.58 (Ubuntu)
< Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT
< ETag: "e2-65cc8b40e550d"
< Accept-Ranges: bytes
< Content-Length: 226
< Vary: Accept-Encoding
< Content-Type: text/html
<
{ [226 bytes data]
100 226 100 226 0 0 306k 0 --:--:-- --:--:-- --:--:-- 230k
* Connection #0 to host localhost left intact
|
- Die Zeilen, die mit [*] beginnen, enthalten Informationen von [curl]: Es hat für [localhost] zwei Adressen gefunden, die IPv6-Adresse [::1] und die IPv4-Adresse [127.0.0.1], und sich mit der zweiten verbunden;
- die Zeilen, die mit [>] beginnen, sind die Zeilen, die [curl] an den Server [localhost] sendet. Das HTTP-Protokoll wird erkannt;
- die Zeilen, die mit [<] beginnen, sind die Zeilen, die der Server als Antwort sendet;
- die übrigen Zeilen zeigen den Fortschrittsbalken des Downloads.
Die Datei [localhost.html] enthält das angeforderte Dokument. Sie können das überprüfen, indem Sie die Datei in einem Texteditor öffnen.
Fordern wir nun die URL [https://localhost/php8-oct-2026/scripts-console/inet/http/pages/hello.html] an. Um diese URL abzurufen, muss der HTTP-Client über HTTPS kommunizieren können. Das ist beim Client [curl] der Fall. Da das Zertifikat des Servers selbstsigniert ist, [curl] würde die Fortsetzung verweigern. Die Option [--insecure] weist es an, das Zertifikat nicht zu prüfen. Die Konsolenausgabe lautet wie folgt:
| > curl --verbose --insecure --output localhost-https.html https://localhost/php8-oct-2026/scripts-console/inet/http/pages/hello.html
* Host localhost:443 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0* Trying 127.0.0.1:443...
* Connected to localhost (127.0.0.1) port 443
* ALPN: curl offers h2,http/1.1
} [5 bytes data]
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
} [512 bytes data]
* TLSv1.3 (IN), TLS handshake, Server hello (2):
{ [122 bytes data]
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
{ [21 bytes data]
* TLSv1.3 (IN), TLS handshake, Certificate (11):
{ [822 bytes data]
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
{ [264 bytes data]
* TLSv1.3 (IN), TLS handshake, Finished (20):
{ [52 bytes data]
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
} [1 bytes data]
* TLSv1.3 (OUT), TLS handshake, Finished (20):
} [52 bytes data]
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / RSASSA-PSS
* ALPN: server accepted http/1.1
* Server certificate:
* subject: CN=localhost
* start date: Oct 1 14:55:35 2026 GMT
* expire date: Sep 28 14:55:35 2036 GMT
* issuer: CN=localhost
* SSL certificate verify result: self-signed certificate (18), continuing anyway.
* Certificate level 0: Public key type RSA (2048/112 Bits/secBits), signed using sha256WithRSAEncryption
* using HTTP/1.x
} [5 bytes data]
> GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
> Host: localhost
> User-Agent: curl/8.5.0
> Accept: */*
>
{ [5 bytes data]
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
{ [57 bytes data]
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
{ [57 bytes data]
* old SSL session ID is stale, removing
{ [5 bytes data]
< HTTP/1.1 200 OK
< Date: Thu, 01 Oct 2026 15:32:56 GMT
< Server: Apache/2.4.58 (Ubuntu)
< Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT
< ETag: "e2-65cc8b40e550d"
< Accept-Ranges: bytes
< Content-Length: 226
< Vary: Accept-Encoding
< Content-Type: text/html
<
{ [226 bytes data]
100 226 100 226 0 0 45798 0 --:--:-- --:--:-- --:--:-- 47200
* Connection #0 to host localhost left intact
|
- Die Zeilen [TLSv1.3 ...] zeigen die Austauschvorgänge zwischen Client und Server zur Absicherung der Verbindung: Die Verbindung wird verschlüsselt;
- die Zeilen [Server certificate] beschreiben das vom Server gesendete Zertifikat. Es wurde für den Rechner [localhost] (CN=localhost) von demselben Rechner ausgestellt (issuer: CN=localhost): Es ist ein selbstsigniertes Zertifikat. [curl] meldet, dass es das Zertifikat nicht überprüfen konnte, macht aber trotzdem weiter;
- Danach folgen die üblichen verschlüsselten HTTP-Austauschvorgänge. [HTTP/1.1 200 OK]: Das angeforderte Dokument wurde gefunden.
Fordern wir nun die URL [http://localhost/php8-oct-2026/scripts-console/inet/http/pages] an. Wir hatten gesehen, dass es für diese URL eine Weiterleitung auf dieselbe URL mit abschließendem Zeichen / gibt. Die Konsolenausgabe lautet dann wie folgt:
| > curl --verbose --location --output pages.html http://localhost/php8-oct-2026/scripts-console/inet/http/pages
* Host localhost:80 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0* Trying 127.0.0.1:80...
* Connected to localhost (127.0.0.1) port 80
> GET /php8-oct-2026/scripts-console/inet/http/pages HTTP/1.1
> Host: localhost
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 301 Moved Permanently
< Date: Thu, 01 Oct 2026 15:32:56 GMT
< Server: Apache/2.4.58 (Ubuntu)
< Location: http://localhost/php8-oct-2026/scripts-console/inet/http/pages/
< Content-Length: 346
< Content-Type: text/html; charset=iso-8859-1
<
* Ignoring the response-body
100 346 100 346 0 0 637k 0 --:--:-- --:--:-- --:--:-- 337k
* Connection #0 to host localhost left intact
* Issue another request to this URL: 'http://localhost/php8-oct-2026/scripts-console/inet/http/pages/'
* Found bundle for host: 0x562ea38dc400 [serially]
* Can not multiplex, even if we wanted to
* Re-using existing connection with host localhost
> GET /php8-oct-2026/scripts-console/inet/http/pages/ HTTP/1.1
> Host: localhost
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Date: Thu, 01 Oct 2026 15:32:56 GMT
< Server: Apache/2.4.58 (Ubuntu)
< X-Powered-By: PHP/8.5.11
< Vary: Accept-Encoding
< Transfer-Encoding: chunked
< Content-Type: text/html; charset=UTF-8
<
{ [97 bytes data]
100 170 0 170 0 0 147k 0 --:--:-- --:--:-- --:--:-- 147k
* Connection #0 to host localhost left intact
|
- Wir verwenden die Option [--location], um anzugeben, dass wir den vom Server gesendeten Weiterleitungen folgen möchten;
- [HTTP/1.1 301 Moved Permanently] und [Location]: Der Server zeigt an, dass sich das angeforderte Dokument unter einer anderen URL befindet;
- [Issue another request to this URL]: [curl] sendet eine neue Anfrage, diesmal an die neue URL, und verwendet dieselbe Verbindung erneut;
- [HTTP/1.1 200 OK]: Der Server antwortet, dass er das angeforderte Dokument gefunden hat;
- [Transfer-Encoding: chunked]: Er sendet es in Teilen. [curl] entfernt die Chunk-Größen.
Das angeforderte Dokument finden Sie in der Datei [pages.html].
16.4.6. Beispiel 6
PHP verfügt über eine Erweiterung namens [curl] , mit der sich die Fähigkeiten des Werkzeugs [curl] in einem PHP-Programm nutzen lassen. Sie ist in dem PHP aus [Laragon] aktiviert: Das lässt sich mit dem Befehl [php -m] überprüfen, der die geladenen Erweiterungen auflistet. Wäre sie nicht aktiviert, müssten Sie die Zeile [extension=curl] in der Datei [php.ini] auskommentieren.
Wir schreiben ein Skript namens [http-02.php] , das die folgende Konfigurationsdatei verwendet: JSON [config-http-02.json]:
| {
"localhost": {
"timeout": 5,
"url": "http://localhost/php8-oct-2026/scripts-console/inet/http/pages"
},
"localhost-https": {
"timeout": 5,
"url": "https://localhost/php8-oct-2026/scripts-console/inet/http/pages/hello.html",
"verify-peer": false
}
}
|
Jeder Eintrag des Dictionarys [key => value] hat die folgende Struktur:
- key: ein Name, der zur Benennung der Datei dient, in der das Dokument gespeichert wird;
- value: ein Dictionary mit den folgenden Schlüsseln:
- timeout: maximale Wartezeit auf eine Antwort des Servers. Nach Ablauf dieser Zeit trennt der Client die Verbindung;
- url: URL des angeforderten Dokuments;
- verify-peer: Soll das Zertifikat des Servers (HTTPS) geprüft werden? Standardmäßig true.
Der Code des Skripts [http-02.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// HTTP-Client, geschrieben mit der Erweiterung [curl] von PHP
// kann HTTPS sprechen, Weiterleitungen folgen und ein in Chunks gesendetes Dokument empfangen
// Konstanten
const CONFIG_FILE_NAME = "config-http-02.json";
// wir rufen die Konfiguration ab
$config = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// den HTML-Text der URLs der Konfigurationsdatei abrufen
foreach ($config as $site => $info) {
// Lesen der URL der Site $site
$result = getUrl($site, $info["url"], $info["timeout"], $info["verify-peer"] ?? true);
// Ergebnisanzeige
print "$result\n";
}
// --------------------------------------------------------------------------
function getUrl(string $site, string $url, int $timeout, bool $verifyPeer = true): string
{
// liest die URL $url und speichert sie in der Datei output/$site.html
//
// Nachverfolgung
print "Client: start of the communication with the server [$site] ----------------------------\n";
// Initialisierung einer cURL-Sitzung: seit PHP 8.0 gibt [curl_init] ein [CurlHandle]-Objekt zurück
$curl = curl_init($url);
if ($curl === false) {
return "Error while initializing the cURL session for the site [$site]";
}
// curl-Optionen
$options = [
// Verbose-Modus: der Austausch zwischen Client und Server wird angezeigt...
CURLOPT_VERBOSE => true,
// ... auf der Standardausgabe (standardmäßig ist es die Fehlerausgabe)
CURLOPT_STDERR => STDOUT,
// neue Verbindung - kein Cache
CURLOPT_FRESH_CONNECT => true,
// Timeout der Anfrage (in Sekunden)
CURLOPT_TIMEOUT => $timeout,
CURLOPT_CONNECTTIMEOUT => $timeout,
// ob die Gültigkeit des Serverzertifikats (HTTPS) geprüft wird oder nicht
CURLOPT_SSL_VERIFYPEER => $verifyPeer,
CURLOPT_SSL_VERIFYHOST => $verifyPeer ? 2 : 0,
// Weiterleitungen folgen
CURLOPT_FOLLOWLOCATION => true,
// das angeforderte Dokument als Zeichenkette abrufen
CURLOPT_RETURNTRANSFER => true,
];
// curl-Konfiguration
curl_setopt_array($curl, $options);
// Ausführung der Anfrage
$pageContent = curl_exec($curl);
// die cURL-Sitzung wird automatisch geschlossen, wenn das Objekt $curl verschwindet
// ([curl_close] ist seit PHP 8.0 nutzlos und seit PHP 8.5 veraltet)
//
// Verwendung des Ergebnisses
if ($pageContent === false) {
// es gab einen Kommunikationsfehler
return "Error communicating with the server [$site]: " . curl_error($curl);
}
// Speichern des Ergebnisses in output/$site.html
if (!is_dir("output")) {
mkdir("output");
}
if (file_put_contents("output/$site.html", $pageContent) === false) {
return "Error while creating the file [output/$site.html]";
}
// erfolgreiche Rückkehr
return "End of the communication with the server [$site]. Check the file [output/$site.html]";
}
|
Hinweise:
- Zeile 12: Aus der Konfigurationsdatei wird das Dictionary [$config] erstellt;
- Zeile 15: Wir durchlaufen die in der Konfiguration gefundene Liste der Sites;
- Zeile 17: Für jede Site wird die Funktion [getUrl] aufgerufen, um die URL [$info["url"]] mit einem Timeout von [$info["timeout"]] herunterzuladen;
- Zeile 30: Eine [curl]-Sitzung wird gestartet. [curl_init] verbindet sich noch nicht mit dem Webserver. Seit PHP 8.0 gibt die Funktion ein Objekt der Klasse [CurlHandle] (statt einer Ressource) zurück, das als Parameter für alle folgenden [curl]-Funktionen dient. Schlägt die Initialisierung der Sitzung fehl, gibt die Funktion den booleschen Wert [false] zurück;
- Zeilen 35–52: Das Dictionary [$options] konfiguriert die [curl] -Verbindung zum Server:
- [CURLOPT_VERBOSE]: zeigt die Austauschvorgänge zwischen Client und Server an, ähnlich der Option [--verbose] des Werkzeugs [curl]. [CURLOPT_STDERR] leitet sie an die Standardausgabe ([STDOUT]) statt an die Fehlerausgabe um, wodurch die Reihenfolge der Anzeigen erhalten bleibt;
- [CURLOPT_SSL_VERIFYPEER] und [CURLOPT_SSL_VERIFYHOST]: Das Zertifikat des Servers und den darin enthaltenen Namen prüfen;
- [CURLOPT_FOLLOWLOCATION]: Weiterleitungen folgen, ähnlich der Option [--location];
- [CURLOPT_RETURNTRANSFER]: gibt das empfangene Dokument als Zeichenkette zurück;
- Zeile 54: Die Verbindungsoptionen werden an das Objekt [$curl] übergeben;
- Zeile 56: Verbindung zur angeforderten URL mit den definierten Optionen. Wegen der Option [CURLOPT_RETURNTRANSFER => true] gibt die Funktion [curl_exec] das vom Server gesendete Dokument als Zeichenkette zurück, ohne Chunk-Größen, falls es in Teilen gesendet wurde. Die Funktion [curl_exec] gibt den booleschen Wert [false] zurück, wenn die Verbindung fehlschlägt. Die Funktion [curl_error] liefert dann die Fehlerursache;
- Zeile 57: Der PHP-7-Kurs schloss die Sitzung mit der Funktion [curl_close]. Seit PHP 8.0 bewirkt diese Funktion nichts mehr: Die Sitzung wird geschlossen, sobald das Objekt [CurlHandle] nicht mehr verwendet wird. Seit PHP 8.5 ist sie veraltet (deprecated);
- Zeile 69: Die empfangene Seite wird in einer lokalen Datei gespeichert.
Wenn das Skript [http-02.php] ausgeführt wird, erscheint die folgende Konsolenausgabe:
| > php http-02.php
Client: start of the communication with the server [localhost] ----------------------------
* Host localhost:80 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
* Trying 127.0.0.1:80...
* Connected to localhost (127.0.0.1) port 80
> GET /php8-oct-2026/scripts-console/inet/http/pages HTTP/1.1
Host: localhost
Accept: */*
< HTTP/1.1 301 Moved Permanently
< Date: Thu, 01 Oct 2026 16:47:51 GMT
< Server: Apache/2.4.58 (Ubuntu)
< Location: http://localhost/php8-oct-2026/scripts-console/inet/http/pages/
< Content-Length: 346
< Content-Type: text/html; charset=iso-8859-1
<
* Ignoring the response-body
* Connection #0 to host localhost left intact
* Issue another request to this URL: 'http://localhost/php8-oct-2026/scripts-console/inet/http/pages/'
* Found bundle for host: 0x557b108f4920 [serially]
* Can not multiplex, even if we wanted to
* Re-using existing connection with host localhost
> GET /php8-oct-2026/scripts-console/inet/http/pages/ HTTP/1.1
Host: localhost
Accept: */*
< HTTP/1.1 200 OK
< Date: Thu, 01 Oct 2026 16:47:51 GMT
< Server: Apache/2.4.58 (Ubuntu)
< X-Powered-By: PHP/8.5.11
< Vary: Accept-Encoding
< Transfer-Encoding: chunked
< Content-Type: text/html; charset=UTF-8
<
* Connection #0 to host localhost left intact
End of the communication with the server [localhost]. Check the file [output/localhost.html]
Client: start of the communication with the server [localhost-https] ----------------------------
* Host localhost:443 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
* Trying 127.0.0.1:443...
* Connected to localhost (127.0.0.1) port 443
* ALPN: curl offers h2,http/1.1
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / RSASSA-PSS
* ALPN: server accepted http/1.1
* Server certificate:
* subject: CN=localhost
* start date: Oct 1 14:55:35 2026 GMT
* expire date: Sep 28 14:55:35 2036 GMT
* issuer: CN=localhost
* SSL certificate verify result: self-signed certificate (18), continuing anyway.
* Certificate level 0: Public key type RSA (2048/112 Bits/secBits), signed using sha256WithRSAEncryption
* using HTTP/1.x
> GET /php8-oct-2026/scripts-console/inet/http/pages/hello.html HTTP/1.1
Host: localhost
Accept: */*
* old SSL session ID is stale, removing
< HTTP/1.1 200 OK
< Date: Thu, 01 Oct 2026 16:47:51 GMT
< Server: Apache/2.4.58 (Ubuntu)
< Last-Modified: Thu, 01 Oct 2026 15:02:24 GMT
< ETag: "e2-65cc8b40e550d"
< Accept-Ranges: bytes
< Content-Length: 226
< Vary: Accept-Encoding
< Content-Type: text/html
<
* Connection #0 to host localhost left intact
End of the communication with the server [localhost-https]. Check the file [output/localhost-https.html]
|
Es finden dieselben Datenaustauschvorgänge statt wie beim Werkzeug [curl]: Zeilen, die mit [>] beginnen, werden an den Server gesendet; Zeilen, die mit [<] beginnen, werden vom Server empfangen; und Zeilen, die mit [*] beginnen, enthalten Informationen von [curl]. Die Weiterleitung wurde befolgt, und die HTTPS-Verbindung wurde aufgebaut.
16.4.7. Fazit
In diesem Abschnitt haben wir das HTTP-Protokoll untersucht und ein Skript [http-02.php] geschrieben, das eine URL aus dem Web herunterladen kann. Im nächsten Kapitel verwenden wir dafür die Komponente [HttpClient] des Symfony-Frameworks.
16.5. Das SMTP-Protokoll (Simple Mail Transfer Protocol)
16.5.1. Einführung

In diesem Kapitel:
- [Server B] ist ein lokaler SMTP-Server, den wir installieren;
- [Client A] ist ein SMTP-Client in verschiedenen Formen:
- der Client [tcp-client.php], um das SMTP-Protokoll kennenzulernen;
- ein PHP-Skript, das das mit [tcp-client.php] kennengelernte SMTP-Protokoll nachbildet;
- ein PHP-Skript, das die Bibliothek [Symfony Mailer] verwendet, um E-Mails aller Art zu versenden.
16.5.2. Installation eines SMTP-Testservers: [Mailpit]
Im PHP-7-Kurs wurde der – nicht mehr gepflegte – Mailserver [hMailServer] installiert und so konfiguriert, dass er E-Mails über den SMTP-Server von Gmail weiterleitet. Stattdessen verwenden wir [Mailpit] (https://mailpit.axllent.org), ein kostenloses Werkzeug für Entwickler:
- Es ist ein SMTP-Server, der alle an ihn gesendeten E-Mails annimmt, unabhängig von Absender oder Empfänger, sie aber nicht weiterleitet, sondern speichert. Sie können also E-Mails an beliebige Adressen senden, ohne Gefahr zu laufen, jemanden zu belästigen;
- er bietet eine Weboberfläche, über die Sie die empfangenen E-Mails lesen können;
- er stellt außerdem einen POP3-Server bereit, den wir verwenden, um E-Mails programmgesteuert zu lesen;
- Er besteht aus einer einzigen ausführbaren Datei, die keine Installation erfordert.
[Mailpit] kann von https://github.com/axllent/mailpit/releases heruntergeladen werden. Laden Sie unter Windows die Datei [mailpit-windows-amd64.zip] der neuesten Version herunter und kopieren Sie die darin enthaltene Datei [mailpit.exe] in den Ordner [inet/mailpit] im Kurscode. Dieser Ordner enthält bereits die folgenden Dateien:
| mailpit
├── mailpit.bat
├── mailpit-secure.bat
├── pop3-users.txt
├── relay.yml
└── smtp-users.txt
|
Die Datei [pop3-users.txt] definiert die Benutzer des POP3-Servers von [Mailpit] in der Form [user:password]. Es gibt nur einen:
Die Datei [mailpit.bat] startet [Mailpit] mit dieser Benutzerdatei:
| @echo off
rem main instance of Mailpit: SMTP on port 1025, POP3 on port 1110, web interface on port 8025
"%~dp0mailpit.exe" --pop3-auth-file "%~dp0pop3-users.txt"
|
- [%~dp0] gibt den Ordner der Datei [.bat] an: Daher können Sie [mailpit.bat] aus jedem Ordner starten, zum Beispiel per Doppelklick im Windows-Explorer;
- die Option [--pop3-auth-file] startet den POP3-Server von [Mailpit].
Sie können den Befehl auch direkt in ein Terminal eingeben, das im Ordner [inet/mailpit] geöffnet ist: [.\mailpit.exe --pop3-auth-file pop3-users.txt]. [Mailpit] zeigt dann Protokollzeilen an, die besagen, dass es drei Dienste anbietet:
- ein SMTP-Server auf Port 1025 (der Standardport für das SMTP-Protokoll ist Port 25, aber Ports unterhalb von 1024 sind oft reserviert oder gesperrt);
- ein POP3-Server auf Port 1110 (der Standardport ist 110);
- eine Weboberfläche unter der URL [http://localhost:8025].
Das Terminal muss geöffnet bleiben, solange Sie [Mailpit] verwenden möchten: Mit der Tastenkombination [Ctrl-C] beenden Sie es. Empfangene E-Mails werden im Arbeitsspeicher gehalten, solange [Mailpit] läuft. Wir werden [Mailpit] in den kommenden Versionen des Steuerberechnungsservers wieder verwenden, der E-Mails an seinen Administrator senden wird.
Die zweite Datei, [mailpit-secure.bat], startet eine zweite Instanz von [Mailpit], die wir später zur Untersuchung gesicherter Verbindungen verwenden:
| @echo off
rem secure instance of Mailpit: SMTP with mandatory STARTTLS and authentication on port 1587,
rem web interface over HTTPS on port 8026, relay of the messages to the main instance (port 1025)
"%~dp0mailpit.exe" --smtp 0.0.0.0:1587 --listen 0.0.0.0:8026 --ui-tls-cert sans:localhost --ui-tls-key sans:localhost --smtp-tls-cert sans:localhost --smtp-tls-key sans:localhost --smtp-require-starttls --smtp-auth-file "%~dp0smtp-users.txt" --smtp-relay-config "%~dp0relay.yml" --smtp-relay-all
|
- [--smtp 0.0.0.0:1587]: Der SMTP-Server dieser Instanz lauscht auf Port 1587;
- [--listen 0.0.0.0:8026 --ui-tls-cert sans:localhost --ui-tls-key sans:localhost]: Ihre Weboberfläche liegt auf Port 8026 (Port 8025 ist von der ersten Instanz belegt), per HTTPS;
- [--smtp-tls-cert sans:localhost --smtp-tls-key sans:localhost]: [Mailpit] erzeugt sein eigenes selbstsigniertes Zertifikat für den Rechner [localhost]. Dieses Zertifikat ermöglicht es, die Kommunikation mit seinen Clients zu verschlüsseln;
- [--smtp-require-starttls]: Clients müssen die Verbindung verschlüsseln (mit dem Befehl STARTTLS, auf den wir später eingehen), bevor sie eine E-Mail senden;
- [--smtp-auth-file smtp-users.txt]: Clients müssen sich mit einem der Konten in der Datei [smtp-users.txt] authentifizieren. Es gibt nur eines: [guest@localhost] mit dem Passwort [guest];
- [--smtp-relay-config relay.yml --smtp-relay-all]: Eingehende E-Mails werden an den in [relay.yml] definierten SMTP-Server weitergeleitet, das heißt an die erste Instanz von [Mailpit] (localhost, Port 1025):
| # SMTP-Relay der „secure"-Instanz von Mailpit (Port 1587)
# zur Hauptinstanz (Port 1025)
host: localhost
port: 1025
|
Diese zweite Instanz verhält sich wie ein öffentlicher SMTP-Server, zum Beispiel der von Gmail ([smtp.gmail.com], Port 587), der ebenfalls eine verschlüsselte Verbindung und eine Authentifizierung verlangt. Wir verwenden ihn zu gegebener Zeit mit einem Gmail-Konto, für alle, die eines besitzen.
Starten wir die erste Instanz von [Mailpit] und öffnen ihre Weboberfläche [http://localhost:8025] in einem Browser:

Wir werden sehen, wie sich diese Seite im Laufe der Beispiele füllt.
16.5.3. Das SMTP-Protokoll

Wir untersuchen das SMTP-Protokoll in der folgenden Umgebung:
- Client A ist der generische TCP-Client ([tcp-client.php]);
- Server B ist der SMTP-Server von [Mailpit];
- Client A bittet Server B, eine E-Mail an den Benutzer [guest@localhost] zuzustellen;
- wir überprüfen über die Weboberfläche von [Mailpit], dass die E-Mail erfolgreich empfangen wurde.
In einem Terminalfenster, das im Ordner [inet/utilities] geöffnet ist, starten wir den Client und geben die Befehle des SMTP-Protokolls ein:
| > php tcp-client.php --quit bye localhost 1025
Client [127.0.0.1:50072] connected to the server [localhost:1025]
Type your commands (bye to stop):
<-- [220 vm Mailpit ESMTP Service ready]
EHLO localhost
<-- [250-vm greets localhost]
<-- [250-SIZE 52428800]
<-- [250-ENHANCEDSTATUSCODES]
<-- [250-8BITMIME]
<-- [250 SMTPUTF8]
MAIL FROM: <guest@localhost>
<-- [250 2.1.0 Ok]
RCPT TO: <guest@localhost>
<-- [250 2.1.5 Ok]
DATA
<-- [354 Start mail input; end with <CR><LF>.<CR><LF>]
Subject: test
From: guest@localhost
To: guest@localhost
line 1
line 2
.
<-- [250 2.0.0 Ok: queued as 0d0daBzXhAGBiM8Aw3oxZ7]
QUIT
<-- [221 2.0.0 vm Mailpit ESMTP Service closing transmission channel]
Connection with the server lost...
End of the client
|
- [php tcp-client.php --quit bye localhost 1025]: Wir verbinden uns mit Port 1025 des lokalen Rechners, auf dem der SMTP-Dienst von [Mailpit] läuft. Das Argument [--quit bye] gibt an, dass der Benutzer das Programm durch Eingabe des Befehls [bye] verlässt. Ohne dieses Argument lautet der Befehl zum Beenden des Programms [quit]. [QUIT] ist jedoch auch ein Befehl des SMTP-Protokolls. Diese Doppeldeutigkeit müssen wir daher vermeiden;
- [220 vm Mailpit ESMTP Service ready]: Sobald die Verbindung steht, sendet der Server seine Willkommensnachricht. Der Code [220] zeigt an, dass der Server bereit ist. [vm] ist der Name des Rechners, auf dem [Mailpit] läuft: Sie sehen den Namen Ihres Computers;
- [EHLO localhost]: Der Client sendet den Befehl [EHLO client-machine-name]. Der Server antwortet mit einer Reihe von Zeilen der Form [250-xx], deren letzte die Form [250 xx] hat (ein Leerzeichen statt eines Bindestrichs hinter dem Code). Der Code [250] zeigt an, dass der vom Client gesendete Befehl erfolgreich war. Die folgenden Zeilen listen die Erweiterungen des SMTP-Protokolls auf, die der Server unterstützt, etwa die maximale Nachrichtengröße [SIZE];
- [MAIL FROM: <guest@localhost>]: Der Client gibt den Absender der Nachricht an, und der Server akzeptiert ihn (Code 250);
- [RCPT TO: <guest@localhost>]: Der Client gibt den Empfänger der Nachricht an. Für mehrere Empfänger kann es mehrere Befehle [RCPT TO] geben;
- [DATA]: Dieser Befehl teilt dem Server mit, dass der Client im Begriff ist, den Inhalt der Nachricht zu senden. Der Server antwortet mit dem Code [354] und gibt an, wie die Nachricht zu beenden ist;
- Der Client sendet dann eine Liste von Textzeilen, die mit einer Zeile endet, die nur einen einzelnen Punkt enthält. Die Nachricht kann mit den Zeilen [Subject:, From:, To:] beginnen, die jeweils Betreff, Absender und Empfänger der Nachricht festlegen. Auf diese Header muss eine Leerzeile und danach der Nachrichtentext folgen;
- [250 2.0.0 Ok: queued as ...]: Sobald der Server die Zeile mit dem einzelnen Punkt erhalten hat, stellt er die Nachricht zur Zustellung in die Warteschlange;
- [QUIT]: Der Client teilt dem Server mit, dass er fertig ist. Der Server antwortet mit dem Code [221] und schließt dann die Verbindung, was der Client erkennt.
Prüfen wir in der Weboberfläche von [Mailpit], ob der Benutzer [guest@localhost] die Nachricht tatsächlich erhalten hat:

Der Absender steht unter [From], der Empfänger unter [To], der Betreff unter [Subject], und der Nachrichtentext wird angezeigt. Der Tab [Headers] zeigt alle Header der Nachricht, und der Tab [Raw] zeigt den reinen Text, den [Mailpit] empfangen hat.
Unser Client [tcp-client.php] hat die Nachricht erfolgreich gesendet. Wir haben nun das Fundament, um einen in PHP geschriebenen SMTP-Client zu erstellen.
16.5.4. Ein einfacher, in PHP geschriebener SMTP-Client
Wir bilden in PHP nach, was wir zuvor über das SMTP-Protokoll gelernt haben.

Das Skript [inet/smtp/smtp-01.php] wird durch die folgende JSON-Datei [config-smtp-01.json] konfiguriert:
| {
"mail to localhost via localhost": {
"smtp-server": "localhost",
"smtp-port": 1025,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "to localhost via localhost",
"message": "line 1\nline 2\nline 3"
},
"mail to gmail via localhost": {
"smtp-server": "localhost",
"smtp-port": 1025,
"from": "guest@localhost",
"to": "php8parlexemple@gmail.com",
"subject": "to gmail via localhost",
"message": "line 1\nline 2\nline 3"
},
"mail via a secure server": {
"smtp-server": "localhost",
"smtp-port": 1587,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "via a secure server",
"message": "line 1\nline 2\nline 3"
}
}
|
[config-smtp-01.json] ist ein Dictionary, in dem jedes Element die Form [name => info] hat. Der Wert [info] ist selbst ein Dictionary mit den folgenden Schlüsseln und Werten:
- [smtp-server]: der Name des zu verwendenden SMTP-Servers;
- [smtp-port]: die Portnummer des SMTP-Dienstes;
- [from]: der Absender der Nachricht;
- [to]: der Empfänger der Nachricht;
- [subject]: der Betreff der Nachricht;
- [message]: die zu sendende Nachricht.
Es werden drei Nachrichten gesendet:
- Die erste verwendet den SMTP-Server von [Mailpit] , um eine E-Mail an den Benutzer [guest@localhost] zu senden;
- Die zweite verwendet denselben Server, um eine E-Mail an eine Gmail-Adresse zu senden. [Mailpit] behält diese E-Mail bei sich, ohne sie zuzustellen;
- Die dritte verwendet die zweite Instanz von [Mailpit], diejenige auf Port 1587, die eine verschlüsselte Verbindung verlangt. Daher muss [mailpit-secure.bat] gestartet worden sein.
Der Code [smtp-01.php] des SMTP-Clients lautet wie folgt:
| <?php
declare(strict_types=1);
// SMTP-Client (Simple Mail Transfer Protocol) zum Senden einer Nachricht
// SMTP-Kommunikationsprotokoll zwischen Client und Server
// -> der Client verbindet sich mit dem Port des SMTP-Servers (25, 587, 1025...)
// <- der Server sendet ihm eine Willkommensnachricht
// -> der Client sendet den Befehl EHLO Name seines Rechners
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl MAIL FROM: <sender>
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl RCPT TO: <recipient>
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl DATA
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet alle Zeilen seiner Nachricht und schließt mit einer Zeile, die ausschließlich das Zeichen .
// enthält
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl QUIT
// <- der Server antwortet mit OK oder nicht
// die Antworten des Servers haben die Form xxx Text, wobei xxx eine 3-stellige Zahl ist. Jede
// Zahl xxx >= 400 signalisiert einen Fehler.
// Die Antwort kann mehrere Zeilen der Form xxx-Text haben, außer der letzten,
// die die Form xxx Text hat (Leerzeichen nach dem Code)
// die ausgetauschten Textzeilen müssen mit den Zeichen CR (13) und LF (10) enden
// die Parameter zum Senden der Mails
const CONFIG_FILE_NAME = "config-smtp-01.json";
// wir rufen die Konfiguration ab
$mails = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// Senden der Mails
foreach ($mails as $name => $info) {
// Nachverfolgung
print "Sending the mail [$name]\n";
// Senden der Mail
$result = sendmail($info, verbose: true);
// Ergebnisanzeige
print "$result\n";
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function sendmail(array $info, bool $verbose = true): string
{
// sendet die durch [$info] beschriebene Nachricht
// wenn $verbose=true, wird der Austausch zwischen Client und Server nachverfolgt
//
// der Name des Client-Rechners
$client = gethostname();
// Öffnen einer Verbindung zum SMTP-Server
$connection = @stream_socket_client("tcp://{$info["smtp-server"]}:{$info["smtp-port"]}", $errorNumber, $error);
if ($connection === false) {
return "Failed to connect to the server [{$info["smtp-server"]}:{$info["smtp-port"]}]: $error";
}
// $connection stellt einen bidirektionalen Kommunikationsstrom
// zwischen dem Client (diesem Programm) und dem kontaktierten SMTP-Server dar
try {
// nach dem Verbindungsaufbau sendet der Server eine Willkommensnachricht, die wir lesen
sendCommand($connection, "", $verbose);
// Befehl EHLO
sendCommand($connection, "EHLO $client", $verbose);
// Befehl MAIL FROM:
sendCommand($connection, "MAIL FROM: <{$info["from"]}>", $verbose);
// Befehl RCPT TO:
sendCommand($connection, "RCPT TO: <{$info["to"]}>", $verbose);
// Befehl DATA
sendCommand($connection, "DATA", $verbose);
// die Nachricht: Header (From, To, Subject), eine Leerzeile, der Text
// und eine auf einen Punkt reduzierte Zeile
// die Zeilenenden des Textes müssen \r\n sein
$text = str_replace("\n", "\r\n", $info["message"]);
// eine Zeile des Textes, die mit einem Punkt beginnt, muss mit zwei Punkten beginnen
$text = preg_replace('/^\./m', '..', $text);
$data = "From: {$info["from"]}\r\nTo: {$info["to"]}\r\nSubject: {$info["subject"]}\r\n\r\n$text\r\n.";
sendCommand($connection, $data, $verbose);
// Befehl QUIT
sendCommand($connection, "QUIT", $verbose);
return "Message sent";
} catch (RuntimeException $ex) {
// der Server hat einen Fehler signalisiert
return "Error: " . $ex->getMessage();
} finally {
// in jedem Fall schließen wir die Verbindung
fclose($connection);
}
}
// --------------------------------------------------------------------------
function sendCommand($connection, string $command, bool $verbose): void
{
// sendet $command in den Kanal $connection und liest die Antwort des Servers
// Verbose-Modus, wenn $verbose=true
// wirft eine RuntimeException, wenn der Server einen Fehler signalisiert
//
// Senden des Befehls, wenn er nicht leer ist
if ($command !== "") {
fwrite($connection, "$command\r\n");
if ($verbose) {
display($command, 1);
}
}
// Lesen der Antwort: Zeilen [xxx-text], beendet durch eine Zeile [xxx text]
do {
$response = fgets($connection);
if ($response === false) {
throw new RuntimeException("the server has closed the connection");
}
if ($verbose) {
display($response, 2);
}
} while (substr($response, 3, 1) === "-");
// Code der Antwort
$code = (int) substr($response, 0, 3);
// vom Server zurückgegebener Fehler?
if ($code >= 400) {
throw new RuntimeException(rtrim(substr($response, 4)));
}
}
// --------------------------------------------------------------------------
function display(string $exchange, int $direction): void
{
// zeigt $exchange auf dem Bildschirm an
// bei $direction=1 wird --> [$exchange] angezeigt (mit Zeilenenden \n statt \r\n)
// bei $direction=2 wird <-- [$exchange] ohne die Zeilenende-Zeichen \r\n angezeigt
print match ($direction) {
1 => "--> [" . str_replace("\r\n", "\n", $exchange) . "]\n",
2 => "<-- [" . rtrim($exchange, "\r\n") . "]\n",
};
}
|
Hinweise:
- Zeile 32: Die Konfigurationsdatei wird verarbeitet. Der zweite Parameter [true], von [json_decode] verlangt assoziative Arrays statt Objekten;
- Zeile 35: Wir durchlaufen die Elemente des Dictionarys [$mails]. Jedes Element hat die Form [name => info], wobei [name] ein beliebiger Name und [info] ein Dictionary mit den zum Senden einer E-Mail nötigen Informationen ist;
- Zeile 39: Die E-Mail wird von der Funktion [sendmail], gesendet, die zwei Parameter hat:
- $info: das Dictionary mit den zum Senden der E-Mail nötigen Informationen;
- $verbose: ein boolescher Wert, der angibt, ob die Austauschvorgänge zwischen Client und Server auf der Konsole angezeigt werden sollen oder nicht. Beachten Sie das benannte Argument [verbose: true] (PHP 8.0), das den Aufruf lesbarer macht als ein einfaches [true];
- Zeile 53: der Name des Client-Rechners, der vom Befehl EHLO verwendet wird;
- Zeile 55: Öffnen einer Verbindung zum SMTP-Server. Im PHP-7-Kurs wurde die Funktion [fsockopen] verwendet, die weiterhin verfügbar ist. [stream_socket_client] ist allgemeiner: Diese haben wir in [tcp-client.php] verwendet;
- Zeilen 61–86: Die Funktion [sendmail] sendet die verschiedenen Befehle, die ein SMTP-Client senden muss: Lesen der Willkommensnachricht, EHLO, MAIL FROM, RCPT TO, DATA, die Nachricht, QUIT. Jeder Befehl wird von der Funktion [sendCommand] gesendet, die eine [RuntimeException]-Ausnahme auslöst, wenn der Server mit einem Fehlercode antwortet. Alle Befehle stehen daher in einem [try]-Block: Der erste Fehler führt dazu, dass das Programm in den [catch]-Block springt, der die Fehlermeldung zurückgibt. Der [finally]-Block wird in allen Fällen ausgeführt: Hier wird die Verbindung geschlossen. Der Code ist somit viel kürzer als der des PHP-7-Kurses, der das Ergebnis jedes Befehls prüfte;
- Zeilen 75–78: Vorbereitung der Nachricht. Die Zeilen der Nachricht müssen mit \r\n enden. Wenn eine Textzeile nur einen Punkt enthält, geht der Server davon aus, dass die Nachricht zu Ende ist. Um dies zu verhindern, verlangt das SMTP-Protokoll vom Client, den Punkt am Zeilenanfang zu verdoppeln: Der Server entfernt diesen zusätzlichen Punkt wieder. Der reguläre Ausdruck [/^\./m] (Option m: mehrzeilig) erfasst einen Punkt am Zeilenanfang;
- Zeile 93: Die Funktion [sendCommand] ist dafür zuständig, die Befehle des Clients an den SMTP-Server zu senden und die Antwort zu lesen. Sie akzeptiert drei Parameter:
- [$connection]: die Verbindung zwischen Client und Server;
- [$command]: der zu sendende Befehl. Ist er leer, wird nichts gesendet; die Funktion liest dann nur eine Antwort (wie im Fall der Willkommensnachricht);
- [$verbose]: Wenn true, werden die Austauschvorgänge zwischen Client und Server auf der Konsole angezeigt;
- Zeilen 107–115: Liest alle Zeilen der Antwort. Jede Zeile hat die Form [XXX-YYY], wobei XXX ein numerischer Code ist, mit Ausnahme der letzten Zeile der Antwort, die die Form [XXX YYY] hat (der Bindestrich fehlt). Die Schleife [do ... while] endet daher, wenn das vierte Zeichen der Zeile kein Bindestrich ist;
- Zeile 119: Wenn der numerische Code XXX größer oder gleich 400 ist, hat der Server einen Fehler zurückgegeben (4xx-Codes zeigen temporäre Fehler an, 5xx-Codes dauerhafte Fehler);
- Zeile 125: Die Funktion [display] verwendet einen [match] -Ausdruck, um je nach Richtung des Austauschs den anzuzeigenden Text auszuwählen.
Die Ausführung des Skripts erzeugt die folgende Konsolenausgabe:
| > php smtp-01.php
Sending the mail [mail to localhost via localhost]
<-- [220 vm Mailpit ESMTP Service ready]
--> [EHLO vm]
<-- [250-vm greets vm]
<-- [250-SIZE 52428800]
<-- [250-ENHANCEDSTATUSCODES]
<-- [250-8BITMIME]
<-- [250 SMTPUTF8]
--> [MAIL FROM: <guest@localhost>]
<-- [250 2.1.0 Ok]
--> [RCPT TO: <guest@localhost>]
<-- [250 2.1.5 Ok]
--> [DATA]
<-- [354 Start mail input; end with <CR><LF>.<CR><LF>]
--> [From: guest@localhost
To: guest@localhost
Subject: to localhost via localhost
line 1
line 2
line 3
.]
<-- [250 2.0.0 Ok: queued as 5SoJJqMUYg3ZrkBqoVKLQo]
--> [QUIT]
<-- [221 2.0.0 vm Mailpit ESMTP Service closing transmission channel]
Message sent
Sending the mail [mail to gmail via localhost]
<-- [220 vm Mailpit ESMTP Service ready]
--> [EHLO vm]
<-- [250-vm greets vm]
<-- [250-SIZE 52428800]
<-- [250-ENHANCEDSTATUSCODES]
<-- [250-8BITMIME]
<-- [250 SMTPUTF8]
--> [MAIL FROM: <guest@localhost>]
<-- [250 2.1.0 Ok]
--> [RCPT TO: <php8parlexemple@gmail.com>]
<-- [250 2.1.5 Ok]
--> [DATA]
<-- [354 Start mail input; end with <CR><LF>.<CR><LF>]
--> [From: guest@localhost
To: php8parlexemple@gmail.com
Subject: to gmail via localhost
line 1
line 2
line 3
.]
<-- [250 2.0.0 Ok: queued as 78JcBpdQn6ACCrBcnniPz3]
--> [QUIT]
<-- [221 2.0.0 vm Mailpit ESMTP Service closing transmission channel]
Message sent
Sending the mail [mail via a secure server]
<-- [220 vm Mailpit ESMTP Service ready]
--> [EHLO vm]
<-- [250-vm greets vm]
<-- [250-SIZE 52428800]
<-- [250-STARTTLS]
<-- [250-AUTH LOGIN PLAIN]
<-- [250-ENHANCEDSTATUSCODES]
<-- [250-8BITMIME]
<-- [250 SMTPUTF8]
--> [MAIL FROM: <guest@localhost>]
<-- [530 5.7.0 Must issue a STARTTLS command first]
Error: 5.7.0 Must issue a STARTTLS command first
Done
|
- Die ersten beiden Sendungen sind erfolgreich;
- die dritte schlägt fehl: Nach dem Befehl [MAIL FROM] gibt der Server auf Port 1587 den Fehlercode 530 mit der Meldung [Must issue a STARTTLS command first] zurück. Beachten Sie, dass er in seiner Antwort auf den Befehl EHLO die Erweiterung [STARTTLS] und die Authentifizierung [AUTH LOGIN PLAIN] angekündigt hat. Der SMTP-Client muss zuerst die Verbindung verschlüsseln (Befehl STARTTLS) und sich dann authentifizieren (Befehl AUTH). Unser Client hat das nicht getan und wird daher abgewiesen. Der SMTP-Server von Gmail ([smtp.gmail.com], Port 587) antwortet exakt genauso.
Die Weboberfläche von [Mailpit] zeigt die empfangenen E-Mails an. Beachten Sie, dass die für [php8parlexemple@gmail.com] bestimmte E-Mail tatsächlich dort liegt: [Mailpit] hat sie nicht an Gmail weitergeleitet.
16.5.5. Ein zweiter SMTP-Client mit der Bibliothek [Symfony Mailer]
Der vorherige Client hat mindestens zwei Mängel:
- Er kann keine gesicherte Verbindung verwenden, wenn der Server eine verlangt;
- er kann keine Dateien an die Nachricht anhängen.
In unserem neuen Skript verwenden wir die Bibliothek [Symfony Mailer] (https://symfony.com/doc/current/mailer.html). Im PHP-7-Kurs wurde die Bibliothek [SwiftMailer] verwendet, die seit 2021 nicht mehr gepflegt wird: [Symfony Mailer] ist ihr Nachfolger, geschrieben vom selben Team. Die Bibliothek wurde zusammen mit den übrigen Abhängigkeiten des Kurses mit dem Befehl [composer install] installiert (siehe die Datei [composer.json] im Stammverzeichnis des Ordners [php8-oct-2026]) und befindet sich im Ordner [vendor/symfony/mailer]. Sie verwendet die Komponente [symfony/mime], die Nachrichten beliebigen Formats erzeugen kann.
Das Skript [inet/smtp/smtp-02.php] verwendet die folgende Konfigurationsdatei: JSON [config-smtp-02.json]:
| {
"mail to localhost via localhost": {
"smtp-server": "localhost",
"smtp-port": 1025,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "test-localhost",
"message": "line 1\nline 2\nline 3",
"tls": false,
"attachments": [
"/attachments/Hello from Symfony Mailer.docx",
"/attachments/Hello from Symfony Mailer.pdf",
"/attachments/Hello from Symfony Mailer.odt",
"/attachments/Cours-Tutoriels-Serge-Tahé-1568x268.png",
"/attachments/test-localhost.eml"
]
},
"mail to localhost via a secure server": {
"smtp-server": "localhost",
"smtp-port": 1587,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "test-secure-server",
"message": "line 1\nline 2\nline 3",
"tls": true,
"user": "guest@localhost",
"password": "guest",
"verify-peer": false,
"attachments": [
"/attachments/Hello from Symfony Mailer.pdf"
]
},
"mail to gmail via gmail": {
"enabled": false,
"smtp-server": "smtp.gmail.com",
"smtp-port": 587,
"from": "php8parlexemple@gmail.com",
"to": "php8parlexemple@gmail.com",
"subject": "test-gmail-via-gmail",
"message": "line 1\nline 2\nline 3",
"tls": true,
"user": "php8parlexemple@gmail.com",
"password": "application password",
"verify-peer": true,
"attachments": [
"/attachments/Hello from Symfony Mailer.docx",
"/attachments/Hello from Symfony Mailer.pdf",
"/attachments/Hello from Symfony Mailer.odt",
"/attachments/Cours-Tutoriels-Serge-Tahé-1568x268.png",
"/attachments/test-localhost.eml"
]
}
}
|
Sie enthält dieselben Felder wie die Datei [config-smtp-01.json] sowie zusätzliche Felder:
- [tls]: Auf [true] gesetzt, legt es fest, dass mit dem SMTP-Server eine gesicherte, authentifizierte Verbindung verwendet werden muss. In diesem Fall müssen die folgenden Felder hinzugefügt werden:
- [user]: der Benutzername für die Authentifizierung der Verbindung;
- [password]: das zugehörige Passwort;
- [verify-peer]: Soll das vom Server gesendete Zertifikat geprüft werden? Bei einem öffentlichen Server muss dies geschehen. Bei unserem Testserver, der ein selbstsigniertes Zertifikat hat, müssen Sie den Wert auf [false] setzen;
- [attachments]: gibt die Namen der Dateien an, die an die E-Mail angehängt werden. Sie befinden sich im Ordner [smtp/attachments];
- [enabled]: Bei dem Wert [false] wird das Senden deaktiviert. Das ist beim dritten Versand der Fall, der den SMTP-Server von Gmail verwendet.
Um den SMTP-Server von Gmail zu verwenden, benötigen Sie ein Gmail-Konto (ersetzen Sie [php8parlexemple@gmail.com] durch Ihre Adresse) mit aktivierter Bestätigung in zwei Schritten und müssen dafür im Bereich [Security] Ihrer Google-Konto-Einstellungen ein „App-Passwort“ erstellen. Dieses 16-stellige Passwort ersetzt in Anwendungen wie unserer das Kontopasswort. Tragen Sie es in das Feld [password] ein und ändern Sie den Wert von [enabled] auf [true].
Der Code des Skripts [smtp-02.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// SMTP-Client (Simple Mail Transfer Protocol), geschrieben mit der Bibliothek [Symfony Mailer]
// kann eine sichere Verbindung nutzen und Dateien an die Nachricht anhängen
// Abhängigkeiten
require_once __DIR__ . "/../../../vendor/autoload.php";
use Symfony\Component\Mailer\Mailer;
use Symfony\Component\Mailer\Transport;
use Symfony\Component\Mime\Email;
// die Parameter zum Senden der Mails: die Konfigurationsdatei
// kann als Argument übergeben werden (php smtp-02.php config.json)
$configFileName = $argv[1] ?? "config-smtp-02.json";
// wir rufen die Konfiguration ab
$mails = json_decode(file_get_contents($configFileName), true);
// Senden der Mails
foreach ($mails as $name => $info) {
// Versand in der Konfiguration deaktiviert?
if (($info["enabled"] ?? true) === false) {
print "Sending of the mail [$name] disabled\n";
continue;
}
// Nachverfolgung
print "Sending the mail [$name]\n";
// Senden der Mail
$result = sendmail($name, $info);
// Ergebnisanzeige
print "$result\n";
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function sendmail(string $name, array $info): string
{
// sendet $info["message"] an den SMTP-Server $info["smtp-server"] auf dem Port $info["smtp-port"]
// wenn $info["tls"] true ist, ist die Verbindung sicher und authentifiziert
// die Mail wird im Namen von $info["from"] gesendet
// an den Empfänger $info["to"]
// die Dokumente $info["attachments"] werden der Nachricht angehängt
// die Nachricht hat den Betreff $info["subject"]
//
try {
// Erzeugung der Nachricht
$email = (new Email())
// Absender
->from($info["from"])
// Empfänger (es können mehrere sein: to(a, b, c), cc(...), bcc(...))
->to($info["to"])
// Betreff der Nachricht
->subject($info["subject"])
// Text der Nachricht
->text($info["message"])
// HTML-Variante des Textes
->html("<b>" . str_replace("\n", "<br/>", $info["message"]) . "</b>");
// Anhänge
foreach ($info["attachments"] as $attachment) {
// Pfad des Anhangs
$fileName = __DIR__ . $attachment;
// wir prüfen, ob die Datei existiert
if (file_exists($fileName)) {
// wir hängen das Dokument an die Nachricht an
$email->attachFromPath($fileName);
} else {
print "The attachment [$fileName] does not exist\n";
}
}
// der Transport der Nachricht: ein DSN (Data Source Name) der Form
// smtp://user:password@server:port?options
$dsn = "smtp://{$info["smtp-server"]}:{$info["smtp-port"]}";
if ($info["tls"]) {
// sichere (STARTTLS) und authentifizierte Verbindung
$verifyPeer = ($info["verify-peer"] ?? true) ? 1 : 0;
$dsn = sprintf("smtp://%s:%s@%s:%d?require_tls=1&verify_peer=%d",
rawurlencode($info["user"]), rawurlencode($info["password"]),
$info["smtp-server"], $info["smtp-port"], $verifyPeer);
}
// der Versandmanager
$mailer = new Mailer(Transport::fromDsn($dsn));
// Senden der Nachricht
$mailer->send($email);
// Ende
return "Message [$name] sent";
} catch (Throwable $ex) {
// Fehler
return "Error while sending the message [$name]: " . $ex->getMessage();
}
}
|
Hinweise:
- Zeile 9: Wir laden die von Composer erstellte Datei [vendor/autoload.php]. Mit dieser Datei lassen sich die Klassendefinitionsdateien der Bibliotheken laden, sobald diese Klassen erstmals verwendet werden. Das erspart uns ebenso viele [require]-Anweisungen , wie es Klassen- und Schnittstellendateien von [Symfony Mailer] gibt, die wir verwenden. Der Pfad ist relativ zum Skriptordner ([__DIR__]): Das Skript funktioniert unabhängig vom Speicherort des Ordners [php8-oct-2026];
- Zeilen 11–13: Die Klassen von [Symfony Mailer] liegen in Namensräumen. Die [use]-Anweisungen erlauben es uns, sie mit ihren Kurznamen anzusprechen;
- Zeile 17: Die Konfigurationsdatei kann dem Skript als Argument übergeben werden; andernfalls ist standardmäßig [config-smtp-02.json] vorgegeben;
- Zeile 25: Ein Versand ist deaktiviert, wenn sein Feld [enabled] auf [false] gesetzt ist. Der Operator [??] liefert [true] , wenn das Feld fehlt;
- Zeile 40: Die neue Funktion [sendmail], die zwei Parameter hat:
- [$name], der dazu dient, Nachrichten zu unterscheiden;
- [$info]: die Informationen, die zum Senden der Nachricht an ihren Empfänger nötig sind;
- Zeilen 51–61: Wir definieren die Nachricht mit der Klasse [Email]. Ihre Methoden geben das Objekt selbst zurück, was ihre Verkettung ermöglicht:
- [from] legt den Absender der Nachricht fest;
- [to] legt den Empfänger der Nachricht fest;
- [subject] legt den Betreff der Nachricht fest;
- [text] legt den Textkörper der Nachricht fest;
- [html] definiert eine Variante (HTML) der Nachricht. Hier ersetzen wir die Zeilenendezeichen durch das HTML-Tag [<br/>] und setzen den gesamten Text fett. Hat die Nachricht Varianten, zeigen E-Mail-Programme die vom Benutzer bevorzugte Variante an;
- Zeilen 63–72: Die Methode [attachFromPath] hängt eine Datei an die Nachricht an. Der Dateityp (application/pdf ...) wird aus der Dateiendung abgeleitet;
- Zeilen 76–82: Sobald die zu sendende Nachricht definiert ist, müssen Sie festlegen, wie sie gesendet wird. [Symfony Mailer] beschreibt den Transport der Nachricht über eine Zeichenkette namens DSN (Data Source Name) in der Form [smtp://user:password@server:port?options]. Für eine gesicherte Verbindung werden Benutzer und Passwort hinzugefügt, kodiert mit [rawurlencode] (das Zeichen @ in [guest@localhost] wird zu %40), zusammen mit zwei Optionen: [require_tls=1] verlangt die Verschlüsselung der Verbindung, und [verify_peer=0] deaktiviert die Prüfung des Serverzertifikats. Beachten Sie, dass [Symfony Mailer] automatisch den Befehl STARTTLS verwendet, wenn der Server ihn ankündigt;
- Zeile 85: Die Klasse [Mailer] sendet die Nachrichten. Ihr muss der gewählte Transport übergeben werden, der aus dem DSN mit der statischen Methode [Transport::fromDsn] erstellt wurde;
- Zeile 87: Die Nachricht wird gesendet;
- Zeile 90: Die Bibliothek löst eine Ausnahme aus, sobald etwas schiefgeht.
Wenn das Skript [smtp-02.php] ausgeführt wird (bei bereits laufenden beiden Instanzen von [Mailpit] ), erscheint die folgende Konsolenausgabe:
| > php smtp-02.php
Sending the mail [mail to localhost via localhost]
Message [mail to localhost via localhost] sent
Sending the mail [mail to localhost via a secure server]
Message [mail to localhost via a secure server] sent
Sending of the mail [mail to gmail via gmail] disabled
Done
|
Die Weboberfläche von [Mailpit] zeigt beide Nachrichten an. Die Nachricht [test-secure-server] lief über die gesicherte Instanz, die sie an die Hauptinstanz weitergeleitet hat. Hier ist die Nachricht [test-localhost]:

- Oben rechts zeigt das Abzeichen [Attachments (5)] die fünf Anhänge an, deren Vorschaubilder am unteren Seitenrand zu sehen sind;
- der Tab [HTML] zeigt die HTML-Variante der Nachricht (in Fettschrift), während der Tab [Text] ihre Textvariante zeigt.
Der Tab [Raw] zeigt den reinen Text der empfangenen Nachricht. Hier ist er, ohne die Zeilen, die den Inhalt der Anhänge kodieren:
| Return-Path: <guest@localhost>
Received: from [127.0.0.1] (localhost [127.0.0.1])
by vm (Mailpit) with SMTP
for <guest@localhost>; Thu, 1 Oct 2026 17:14:24 +0200 (CEST)
From: guest@localhost
To: guest@localhost
Subject: test-localhost
Message-ID: <d17f753f0db420a353457b730f2cfdec@localhost>
MIME-Version: 1.0
Date: Thu, 01 Oct 2026 17:14:24 +0200
Content-Type: multipart/mixed; boundary=jM982j4q
--jM982j4q
Content-Type: multipart/alternative; boundary=LUEVyqZR
--LUEVyqZR
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
line 1
line 2
line 3
--LUEVyqZR
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable
<b>line 1<br/>line 2<br/>line 3</b>
--LUEVyqZR--
--jM982j4q
Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document;
name="Hello from Symfony Mailer.docx"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; name="Hello from Symfony Mailer.docx";
filename="Hello from Symfony Mailer.docx"
--jM982j4q
Content-Type: application/pdf; name="Hello from Symfony Mailer.pdf"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; name="Hello from Symfony Mailer.pdf";
filename="Hello from Symfony Mailer.pdf"
--jM982j4q
Content-Type: application/vnd.oasis.opendocument.text;
name="Hello from Symfony Mailer.odt"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; name="Hello from Symfony Mailer.odt";
filename="Hello from Symfony Mailer.odt"
--jM982j4q
Content-Type: image/png;
name="=?utf-8?Q?Cours-Tutoriels-Serge-Tah=C3=A9-1568x268=2Epng?="
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
name*=utf-8''Cours-Tutoriels-Serge-Tah%C3%A9-1568x268.png;
filename*=utf-8''Cours-Tutoriels-Serge-Tah%C3%A9-1568x268.png
--jM982j4q
Content-Type: message/rfc822; name=test-localhost.eml
Content-Transfer-Encoding: base64
Content-Disposition: attachment; name=test-localhost.eml;
filename=test-localhost.eml
--jM982j4q--
|
- [Return-Path] und [Received]: Diese Header wurden von [Mailpit] beim Empfang der Nachricht hinzugefügt. Jeder Server, den eine Nachricht durchläuft, fügt einen Header [Received] hinzu;
- [From], [To], [Subject]: Absender, Empfänger und Betreff;
- [Content-Type: multipart/mixed; boundary=...]: Die Nachricht besteht aus mehreren Teilen, die durch Zeilen mit der Kennzeichnung [--boundary] getrennt sind. Auf den letzten folgt die Zeile [--boundary--]. Dies ist das MIME-Format (Multipurpose Internet Mail Extensions);
- der erste Teil ist selbst vom Typ [multipart/alternative]: Er enthält zwei Varianten der Nachricht, in [text/plain] und in [text/html]. Sie sind in [quoted-printable] kodiert, einer Kodierung, die ASCII-Zeichen unverändert lässt und die übrigen kodiert (é wird zu =C3=A9);
- Danach folgen die fünf Anhänge ([Content-Disposition: attachment]), kodiert als [base64], eine Kodierung, die beliebigen Binärinhalt in Zeilen aus ASCII-Zeichen umwandelt;
- der Dateiname [Cours-Tutoriels-Serge-Tahé-1568x268.png] enthält das Zeichen [é]. Er ist auf zwei Arten kodiert: [name="=?utf-8?Q?...?="] (bekannt als RFC-2047-Kodierung) und [filename*=utf-8''...%C3%A9...] (bekannt als RFC-2231-Kodierung). Wir werden ihnen beim Lesen der E-Mails wieder begegnen;
- der letzte Anhang vom Typ [message/rfc822] ist selbst eine E-Mail: die Datei [test-localhost.eml], die ihrerseits Anhänge hat.
Betrachten wir abschließend zwei häufige Fehler. Die Datei [config-smtp-02-errors.json] beschreibt zwei Sendungen an die gesicherte Instanz: Die erste prüft das Zertifikat des Servers ([verify-peer] auf [true]), und die zweite verwendet ein falsches Passwort:
| {
"server certificate verified": {
"smtp-server": "localhost",
"smtp-port": 1587,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "test-errors",
"message": "line 1\nline 2\nline 3",
"tls": true,
"user": "guest@localhost",
"password": "guest",
"verify-peer": true,
"attachments": []
},
"wrong password": {
"smtp-server": "localhost",
"smtp-port": 1587,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "test-errors",
"message": "line 1\nline 2\nline 3",
"tls": true,
"user": "guest@localhost",
"password": "xx",
"verify-peer": false,
"attachments": []
}
}
|
Führen wir das Skript mit dieser Konfigurationsdatei über den Befehl [php smtp-02.php config-smtp-02-errors.json] aus:
| > php smtp-02.php config-smtp-02-errors.json
Sending the mail [server certificate verified]
Error while sending the message [server certificate verified]: Unable to connect with STARTTLS: stream_socket_enable_crypto(): SSL operation failed with code 1. OpenSSL Error messages:
error:0A000086:SSL routines::certificate verify failed
Sending the mail [wrong password]
Error while sending the message [wrong password]: Failed to authenticate on SMTP server with username "guest@localhost" using the following authenticators: "LOGIN", "PLAIN". Authenticator "LOGIN" returned "Expected response code "235" but got code "535", with message "535 5.7.8 Authentication credentials invalid".". Authenticator "PLAIN" returned "Expected response code "235" but got code "535", with message "535 5.7.8 Authentication credentials invalid".".
Done
|
- Erster Versuch: Das selbstsignierte Zertifikat von [Mailpit] wurde nicht von einer bekannten Zertifizierungsstelle ausgestellt. Die Prüfung schlägt fehl, und der Client verweigert die Fortsetzung – dies schützt einen Client davor, dass sich ein Server als ein anderer ausgibt. Bei [smtp.gmail.com], dessen Zertifikat gültig ist, gelingt die Prüfung;
- Zweiter Versuch: Der Server lehnt die Authentifizierung mit dem Fehlercode 535 ab.
16.6. Die Protokolle POP3 (Post Office Protocol) und IMAP (Internet Message Access Protocol)
16.6.1. Einführung
Es gibt zwei Protokolle zum Lesen von E-Mails, die auf einem Mailserver gespeichert sind:
- das POP3-Protokoll (Post Office Protocol), historisch das erste Protokoll, heute aber selten verwendet;
- das IMAP-Protokoll (Internet Message Access Protocol), das neuer als POP3 ist und derzeit am weitesten verbreitet ist.
Um diese Protokolle zu untersuchen, verwenden wir die folgende Architektur:

- [Server B] ist:
- für POP3 der POP3-Server von [Mailpit] (Port 1110);
- für IMAP ein IMAP-Server. Das könnte der Server von Gmail sein ([imap.gmail.com], Port 993), mit dem Gmail-Konto und dem App-Passwort, die beim SMTP-Protokoll erwähnt wurden. Die hier vorgestellten Ergebnisse wurden mit einem lokalen IMAP-Server erzielt, dem Open-Source-Server [Dovecot] (https://www.dovecot.org), der einen Benutzer namens [guest@localhost] mit dem Passwort [guest] hat. Wir haben die von unseren SMTP-Skripten gesendeten E-Mails im Postfach INBOX dieses Benutzers abgelegt. Mit Gmail erhalten Sie Ergebnisse im selben Format;
- [Client A] ist ein POP3-/IMAP-Client in verschiedenen Formen:
- der Client [tcp-client.php] , um die Protokolle POP3 und IMAP kennenzulernen;
- ein PHP-Skript, das das mit [tcp-client.php] kennengelernte POP3-Protokoll nachbildet;
- PHP-Skripte, die die von uns zu schreibenden POP3- und IMAP-Klassen verwenden, gefolgt von der Bibliothek [zbateson/mail-mime-parser] zum Parsen der Nachrichten.
Im PHP-7-Kurs wurden die Funktionen [imap_*] der PHP-Erweiterung [imap] verwendet, die sowohl IMAP als auch POP3 unterstützte. Diese Erweiterung, die auf einer C-Bibliothek beruhte, welche seit Jahren aufgegeben war, wurde mit PHP 8.4 entfernt. Wir schreiben die benötigten POP3- und IMAP-Clients daher selbst, mit den Socket-Funktionen von PHP. Das ist eine Gelegenheit, diese beiden Protokolle gründlich zu verstehen.
16.6.2. Das POP3-Protokoll erkunden
Zunächst senden wir mit dem Skript [smtp-01.php] zwei E-Mails: eine an [guest@localhost] und die andere an [php8parlexemple@gmail.com] (der dritte Versuch schlägt fehl, wie wir gesehen haben). Der POP3-Server von [Mailpit] stellt alle von [Mailpit] empfangenen E-Mails in einem einzigen Postfach bereit, unabhängig von ihren Empfängern. Um es zu lesen, müssen Sie sich mit einem Benutzer aus der Datei [pop3-users.txt] anmelden – hier [guest] – mit dem Passwort [guest].
Sehen wir, wie wir mit dem Client [tcp-client.php] auf dieses Postfach zugreifen:
| > php tcp-client.php --quit bye localhost 1110
Client [127.0.0.1:47492] connected to the server [localhost:1110]
Type your commands (bye to stop):
<-- [+OK Mailpit POP3 server]
USER guest
<-- [+OK]
PASS guest
<-- [+OK signed in]
LIST
<-- [+OK 2 messages (682 octets)]
<-- [1 349]
<-- [2 333]
<-- [.]
RETR 1
<-- [+OK 349 octets]
<-- [Message-ID: <73n0AqT1QxqOYmrcWH5gK7@mailpit>]
<-- [Return-Path: <guest@localhost>]
<-- [Received: from vm (localhost [127.0.0.1])]
<-- [ by vm (Mailpit) with SMTP]
<-- [ for <php8parlexemple@gmail.com>; Thu, 1 Oct 2026 17:14:31 +0200 (CEST)]
<-- [From: guest@localhost]
<-- [To: php8parlexemple@gmail.com]
<-- [Subject: to gmail via localhost]
<-- []
<-- [line 1]
<-- [line 2]
<-- [line 3]
<-- []
<-- [.]
DELE 1
<-- [+OK message marked for deletion]
LIST
<-- [+OK 1 messages (333 octets)]
<-- [2 333]
<-- [.]
DELE 2
<-- [+OK message marked for deletion]
LIST
<-- [+OK 0 messages (0 octets)]
<-- [.]
QUIT
<-- [+OK goodbye]
Connection with the server lost...
End of the client
|
- [php tcp-client.php --quit bye localhost 1110]: Der POP3-Server verwendet üblicherweise Port 110. Hier ist es Port 1110 bei [Mailpit];
- [USER guest]: Mit dem Befehl [USER] wird der Benutzer angegeben, dessen Postfach gelesen werden soll;
- [PASS guest]: Mit dem Befehl [PASS] wird das Passwort des Benutzers festgelegt;
- [LIST]: Der Befehl [LIST] fordert eine Liste der Nachrichten im Postfach des Benutzers an. Der Server antwortet mit der Anzahl der Nachrichten und ihrer Gesamtgröße, gefolgt von einer Zeile [number size] pro Nachricht;
- [RETR 1]: Der Befehl [RETR] fordert die Nachricht mit der angegebenen Nummer an. Die Header [From], [To] und [Subject] – von [smtp-01.php] gesendet – sind enthalten, zusammen mit den Headern, die [Mailpit] hinzugefügt hat. [Mailpit] zeigt die Nachrichten von der neuesten zur ältesten an: Nachricht Nr. 1 ist die zuletzt empfangene;
- [DELE 1]: Der Befehl [DELE] markiert die Nachricht mit der angegebenen Nummer als „zu löschen“. Die Nachricht erscheint nicht mehr in der Liste;
- [QUIT]: Der Befehl [QUIT] teilt dem Server mit, dass Sie fertig sind. Jetzt löscht der Server die markierten Nachrichten. Beide Nachrichten sind aus der Weboberfläche von [Mailpit] verschwunden.
Die Antwort des Servers kann verschiedene Formen annehmen:
- eine einzelne Zeile, die mit [+OK] beginnt, um anzuzeigen, dass der vorherige Befehl des Clients erfolgreich war;
- eine einzelne Zeile, die mit [-ERR] beginnt, um anzuzeigen, dass der vorherige Befehl des Clients fehlgeschlagen ist;
- mehrere Zeilen, wobei:
- die erste Zeile mit [+OK] beginnt;
- die letzte Zeile nur aus einem einzelnen Punkt besteht.
16.6.3. Ein einfaches Skript, das das POP3-Protokoll implementiert

Da das POP3-Protokoll dieselbe Struktur wie das SMTP-Protokoll hat, ist das Skript [inet/imap/pop3-01.php] eine Portierung des Skripts [smtp-01.php]. Es hat die folgende Konfigurationsdatei, [config-pop3-01.json]:
| {
"localhost:1110": {
"server": "localhost",
"port": 1110,
"user": "guest",
"password": "guest",
"maxmails": 5
}
}
|
- Zeilen 3–4: Der abgefragte POP3-Server ist der Server von [Mailpit];
- Zeilen 5–6: der Benutzer und sein Passwort;
- Zeile 7: Es werden höchstens 5 E-Mails abgerufen.
Das Skript [pop3-01.php] sieht wie folgt aus:
| <?php
declare(strict_types=1);
// POP3-Client (Post Office Protocol) zum Lesen der Nachrichten eines Postfachs
// POP3-Kommunikationsprotokoll zwischen Client und Server
// -> der Client verbindet sich mit dem Port des POP3-Servers (110, 1110...)
// <- der Server sendet ihm eine Willkommensnachricht
// -> der Client sendet den Befehl USER user
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl PASS password
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl LIST
// <- der Server antwortet mit OK oder nicht. Bei OK sendet er die Liste [Nr. Größe] der Nachrichten
// -> der Client sendet für jede der Nachrichten den Befehl RETR Nr.
// <- der Server antwortet mit OK oder nicht. Bei OK sendet er den Inhalt der angeforderten Nachricht
// -> der Client sendet den Befehl DELE Nr., um eine Nachricht zu löschen
// <- der Server antwortet mit OK oder nicht
// -> der Client sendet den Befehl QUIT, um den Dialog mit dem Server zu beenden
// <- der Server antwortet mit OK oder nicht
// die Antworten des Servers haben die Form +OK Text oder -ERR Text
// Die Antwort kann mehrere Zeilen haben. Dann besteht die letzte aus einem einzigen Punkt
// die ausgetauschten Textzeilen müssen mit den Zeichen CR (13) und LF (10) enden
// die Parameter zum Lesen der Postfächer
const CONFIG_FILE_NAME = "config-pop3-01.json";
// wir rufen die Konfiguration ab
$mailboxes = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// Lesen der Postfächer
foreach ($mailboxes as $name => $info) {
// Nachverfolgung
print "Reading the mailbox [$name]\n";
// Lesen des Postfachs
$result = readmail($info, verbose: true);
// Ergebnisanzeige
print "$result\n";
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function readmail(array $info, bool $verbose = true): string
{
// liest höchstens $info["maxmails"] Nachrichten des durch [$info] beschriebenen Postfachs
// jede Nachricht wird nach dem Lesen gelöscht
// wenn $verbose=true, wird der Austausch zwischen Client und Server nachverfolgt
//
// Öffnen einer Verbindung zum POP3-Server
$connection = @stream_socket_client("tcp://{$info["server"]}:{$info["port"]}", $errorNumber, $error);
if ($connection === false) {
return "Failed to connect to the server [{$info["server"]}:{$info["port"]}]: $error";
}
try {
// nach dem Verbindungsaufbau sendet der Server eine Willkommensnachricht, die wir lesen
sendCommand($connection, "", $verbose);
// Befehl USER
sendCommand($connection, "USER {$info["user"]}", $verbose);
// Befehl PASS
sendCommand($connection, "PASS {$info["password"]}", $verbose);
// Befehl LIST: die 1. Zeile der Antwort hat die Form [+OK n messages...]
$response = sendCommand($connection, "LIST", $verbose, multiline: true);
preg_match('/^\+OK (\d+)/', $response[0], $fields);
$nbMessages = (int) ($fields[1] ?? 0);
// wir durchlaufen die Nachrichten
for ($i = 1; $i <= min($nbMessages, $info["maxmails"]); $i++) {
// Befehl RETR: die Nachricht steht in den Zeilen 1 bis n-1 der Antwort
sendCommand($connection, "RETR $i", $verbose, multiline: true);
// Befehl DELE
sendCommand($connection, "DELE $i", $verbose);
}
// Befehl QUIT: er löscht die mit DELE markierten Nachrichten
sendCommand($connection, "QUIT", $verbose);
return "Reading done";
} catch (RuntimeException $ex) {
// der Server hat einen Fehler signalisiert
return "Error: " . $ex->getMessage();
} finally {
// in jedem Fall schließen wir die Verbindung
fclose($connection);
}
}
// --------------------------------------------------------------------------
function sendCommand($connection, string $command, bool $verbose, bool $multiline = false): array
{
// sendet $command in den Kanal $connection und gibt die Zeilen der Antwort zurück
// Verbose-Modus, wenn $verbose=true
// wenn $multiline=true, endet die Antwort mit einer auf einen Punkt reduzierten Zeile
// wirft eine RuntimeException, wenn der Server einen Fehler signalisiert
//
// Senden des Befehls, wenn er nicht leer ist
if ($command !== "") {
fwrite($connection, "$command\r\n");
if ($verbose) {
display($command, 1);
}
}
// Lesen der 1. Zeile der Antwort
$line = readServerLine($connection, $verbose);
// Fehler?
if (str_starts_with($line, "-ERR")) {
throw new RuntimeException(substr($line, 5));
}
$response = [$line];
// mehrzeilige Antwort?
if ($multiline) {
while (($line = readServerLine($connection, $verbose)) !== ".") {
// eine Zeile der Nachricht, die mit einem Punkt beginnt, wurde
// mit einem zusätzlichen Punkt gesendet: wir entfernen ihn
$response[] = str_starts_with($line, "..") ? substr($line, 1) : $line;
}
}
return $response;
}
// --------------------------------------------------------------------------
function readServerLine($connection, bool $verbose): string
{
// liest eine vom Server gesendete Zeile und gibt sie ohne die Zeichen \r\n zurück
$line = fgets($connection);
if ($line === false) {
throw new RuntimeException("the server has closed the connection");
}
$line = rtrim($line, "\r\n");
if ($verbose) {
display($line, 2);
}
return $line;
}
// --------------------------------------------------------------------------
function display(string $exchange, int $direction): void
{
// zeigt $exchange auf dem Bildschirm an
// bei $direction=1 wird --> [$exchange] angezeigt
// bei $direction=2 wird <-- [$exchange] angezeigt
print match ($direction) {
1 => "--> [$exchange]\n",
2 => "<-- [$exchange]\n",
};
}
|
Hinweise
Wie erwähnt, ist [pop3-01.php] eine Portierung des Skripts [smtp-01.php], das wir bereits besprochen haben. Wir kommentieren nur die wichtigsten Unterschiede:
- Zeile 44: Die Funktion [readmail] ist dafür zuständig, die E-Mails aus dem Postfach zu lesen. Die Anmeldeinformationen für dieses Postfach stehen im Dictionary [$info];
- Zeile 51: Baut eine Verbindung zum POP3-Server auf;
- Zeile 57: Liest die vom Server gesendete Willkommensnachricht;
- Zeilen 59–61: Die Befehle [USER] und [PASS] werden gesendet, um den Benutzer zu identifizieren, dessen E-Mails gewünscht sind;
- Zeilen 63–65: Der Befehl [LIST] wird gesendet, um zu ermitteln, wie viele E-Mails im Postfach liegen. Die Funktion [sendCommand] gibt nun die Zeilen der Antwort zurück. In der ersten Zeile seiner Antwort auf den Befehl LIST gibt der Server an, wie viele Nachrichten es gibt. Dies wird mit einem regulären Ausdruck ermittelt. [$fields[1] ?? 0] liefert 0, wenn der reguläre Ausdruck nichts gefunden hat;
- Zeilen 67–71: Wir durchlaufen die Nachrichten. Für jede senden wir zwei Befehle:
- RETR i: um Nachricht Nr. i abzurufen;
- DELE i: um sie zu löschen, sobald sie gelesen wurde;
- Zeile 74: Der Befehl [QUIT] wird gesendet, um dem Server mitzuteilen, dass wir fertig sind;
- Zeile 86: Der Parameter [$multiline] gibt an, ob die erwartete Antwort mehrere Zeilen hat, deren letzte aus einem einzelnen Punkt besteht. Das ist bei den Befehlen [LIST] und [RETR] der Fall. Ein Fehler wird durch eine erste Zeile angezeigt, die mit [-ERR] beginnt (Funktion [str_starts_with] ab PHP 8.0);
- Zeilen 110–112: Wie bei SMTP verdoppelt der Server den Punkt am Anfang einer Nachrichtenzeile. Der Client muss diesen zusätzlichen Punkt entfernen.
Wir senden mit [smtp-01.php] zwei weitere E-Mails und führen dann [pop3-01.php] aus:
| > php pop3-01.php
Reading the mailbox [localhost:1110]
<-- [+OK Mailpit POP3 server]
--> [USER guest]
<-- [+OK]
--> [PASS guest]
<-- [+OK signed in]
--> [LIST]
<-- [+OK 2 messages (682 octets)]
<-- [1 349]
<-- [2 333]
<-- [.]
--> [RETR 1]
<-- [+OK 349 octets]
<-- [Message-ID: <67n1volg9CfPFES6KhEOf7@mailpit>]
<-- [Return-Path: <guest@localhost>]
<-- [Received: from vm (localhost [127.0.0.1])]
<-- [ by vm (Mailpit) with SMTP]
<-- [ for <php8parlexemple@gmail.com>; Thu, 1 Oct 2026 17:14:39 +0200 (CEST)]
<-- [From: guest@localhost]
<-- [To: php8parlexemple@gmail.com]
<-- [Subject: to gmail via localhost]
<-- []
<-- [line 1]
<-- [line 2]
<-- [line 3]
<-- []
<-- [.]
--> [DELE 1]
<-- [+OK message marked for deletion]
--> [RETR 2]
<-- [+OK 333 octets]
<-- [Message-ID: <6ZFzliytBzUvTLo2fEhfiC@mailpit>]
<-- [Return-Path: <guest@localhost>]
<-- [Received: from vm (localhost [127.0.0.1])]
<-- [ by vm (Mailpit) with SMTP]
<-- [ for <guest@localhost>; Thu, 1 Oct 2026 17:14:39 +0200 (CEST)]
<-- [From: guest@localhost]
<-- [To: guest@localhost]
<-- [Subject: to localhost via localhost]
<-- []
<-- [line 1]
<-- [line 2]
<-- [line 3]
<-- []
<-- [.]
--> [DELE 2]
<-- [+OK message marked for deletion]
--> [QUIT]
<-- [+OK goodbye]
Reading done
Done
|
Wir haben hier einen einfachen POP3-Client, dem einige Fähigkeiten fehlen:
- die Fähigkeit, mit einem gesicherten Server zu kommunizieren;
- die Fähigkeit, die Anhänge von Nachrichten zu lesen.
Bevor wir diese Funktionen ergänzen, erkunden wir das IMAP-Protokoll.
16.6.4. Das IMAP-Protokoll erkunden
Das IMAP-Protokoll ist funktionsreicher als das POP3-Protokoll. Der Server verwaltet pro Benutzer mehrere Postfächer (INBOX, Gesendet, Papierkorb usw.) und verfolgt den Status der Nachrichten: gelesen, beantwortet, zu löschen ... Diese Status heißen Flags. Vor allem aber kann der Client vom Server die Struktur einer Nachricht anfordern und nur einen Teil davon herunterladen.
Jedem Befehl des Clients geht ein vom Client gewähltes Tag voran, zum Beispiel [A1]. Der Server antwortet mit Zeilen, die mit einem Sternchen [*] beginnen, gefolgt von einer Zeile, die mit dem Tag des Befehls beginnt, gefolgt von [OK] (Erfolg), [NO] (Fehlschlag) oder [BAD] (ungültiger Befehl).
Öffentliche IMAP-Server akzeptieren ab ihrem Start nur verschlüsselte Verbindungen auf Port 993. Bei Gmail würden Sie den TCP-Client mit der Option [--tls] starten: [php tcp-client.php --tls --quit bye imap.gmail.com 993]. Unser lokaler Server akzeptiert auch unverschlüsselte Verbindungen auf dem Standardport 143, was für das Kennenlernen nützlich ist. Wir haben zwei E-Mails mit dem Skript [smtp-02.php] (Konfiguration [config-smtp-02.json]) gesendet, und sie wurden im Posteingang INBOX des Benutzers [guest@localhost] zugestellt. Hier ist ein Dialog mit dem IMAP-Server:
| > php tcp-client.php --quit bye localhost 143
Client [127.0.0.1:39098] connected to the server [localhost:143]
Type your commands (bye to stop):
<-- [* OK [CAPABILITY IMAP4rev1 SASL-IR LOGIN-REFERRALS ID ENABLE IDLE LITERAL+ STARTTLS AUTH=PLAIN AUTH=LOGIN] Dovecot ready.]
A1 LOGIN guest@localhost guest
<-- [A1 OK [CAPABILITY IMAP4rev1 SASL-IR LOGIN-REFERRALS ID ENABLE IDLE SORT SORT=DISPLAY THREAD=REFERENCES THREAD=REFS THREAD=ORDEREDSUBJECT MULTIAPPEND URL-PARTIAL CATENATE UNSELECT CHILDREN NAMESPACE UIDPLUS LIST-EXTENDED I18NLEVEL=1 CONDSTORE QRESYNC ESEARCH ESORT SEARCHRES WITHIN CONTEXT=SEARCH LIST-STATUS BINARY MOVE SNIPPET=FUZZY PREVIEW=FUZZY PREVIEW STATUS=SIZE SAVEDATE LITERAL+ NOTIFY SPECIAL-USE] Logged in]
A2 SELECT INBOX
<-- [* FLAGS (\Answered \Flagged \Deleted \Seen \Draft)]
<-- [* OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft \*)] Flags permitted.]
<-- [* 2 EXISTS]
<-- [* 2 RECENT]
<-- [* OK [UNSEEN 1] First unseen.]
<-- [* OK [UIDVALIDITY 1790865054] UIDs valid]
<-- [* OK [UIDNEXT 10] Predicted next UID]
<-- [A2 OK [READ-WRITE] Select completed (0.001 + 0.000 secs).]
A3 SEARCH UNSEEN
<-- [* SEARCH 1 2]
<-- [A3 OK Search completed (0.001 + 0.000 secs).]
A4 FETCH 2 (FLAGS RFC822.SIZE BODY.PEEK[HEADER.FIELDS (FROM TO SUBJECT DATE)])
<-- [* 2 FETCH (FLAGS (\Recent) RFC822.SIZE 28101 BODY[HEADER.FIELDS (FROM TO SUBJECT DATE)] {114}]
<-- [From: guest@localhost]
<-- [To: guest@localhost]
<-- [Subject: test-secure-server]
<-- [Date: Thu, 01 Oct 2026 17:14:39 +0200]
<-- []
<-- [)]
<-- [A4 OK Fetch completed (0.001 + 0.000 secs).]
A5 FETCH 2 BODY.PEEK[1.1]
<-- [* 2 FETCH (BODY[1.1] {22}]
<-- [line 1]
<-- [line 2]
<-- [line 3)]
<-- [A5 OK Fetch completed (0.002 + 0.000 + 0.001 secs).]
A6 FETCH 1 BODYSTRUCTURE
<-- [* 1 FETCH (BODYSTRUCTURE ((("text" "plain" ("charset" "utf-8") NIL NIL "quoted-printable" 22 2 NIL NIL NIL NIL)("text" "html" ("charset" "utf-8") NIL NIL "quoted-printable" 35 0 NIL NIL NIL NIL) "alternative" ("boundary" "7tEIKgyZ") NIL NIL NIL)("application" "vnd.openxmlformats-officedocument.wordprocessingml.document" ("name" "Hello from Symfony Mailer.docx") NIL NIL "base64" 13518 NIL ("attachment" ("name" "Hello from Symfony Mailer.docx" "filename" "Hello from Symfony Mailer.docx")) NIL NIL)("application" "pdf" ("name" "Hello from Symfony Mailer.pdf") NIL NIL "base64" 26926 NIL ("attachment" ("name" "Hello from Symfony Mailer.pdf" "filename" "Hello from Symfony Mailer.pdf")) NIL NIL)("application" "vnd.oasis.opendocument.text" ("name" "Hello from Symfony Mailer.odt") NIL NIL "base64" 9514 NIL ("attachment" ("name" "Hello from Symfony Mailer.odt" "filename" "Hello from Symfony Mailer.odt")) NIL NIL)("image" "png" ("name" "=?utf-8?Q?Cours-Tutoriels-Serge-Tah=C3=A9-1568x268=2Epng?=") NIL NIL "base64" 57834 NIL ("attachment" ("filename*" "utf-8''Cours-Tutoriels-Serge-Tah%C3%A9-1568x268.png" "name*" "utf-8''Cours-Tutoriels-Serge-Tah%C3%A9-1568x268.png")) NIL NIL)("message" "rfc822" ("name" "test-localhost.eml") NIL NIL "base64" 149814 (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL) ("text" "plain" ("charset" "us-ascii") NIL NIL "7bit" 0 0 NIL NIL NIL NIL) 1921 NIL ("attachment" ("name" "test-localhost.eml" "filename" "test-localhost.eml")) NIL NIL) "mixed" ("boundary" "9UJIzQkk") NIL NIL NIL))]
<-- [A6 OK Fetch completed (0.001 + 0.000 secs).]
A7 LOGOUT
<-- [* BYE Logging out]
<-- [A7 OK Logout completed (0.001 + 0.000 secs).]
Connection with the server lost...
End of the client
|
- [A1 LOGIN guest@localhost guest]: Der Befehl [LOGIN user password] authentifiziert den Benutzer. Der Server antwortet mit einer Liste der Fähigkeiten des Servers (CAPABILITY);
- [A2 SELECT INBOX]: Der Befehl [SELECT] wählt das Postfach aus, auf das sich die folgenden Befehle beziehen. Der Server listet die verfügbaren Flags (FLAGS), die Anzahl der Nachrichten (2 EXISTS) und die Nummer der ersten ungelesenen Nachricht (UNSEEN 1) auf ...;
- [A3 SEARCH UNSEEN]: Der Befehl [SEARCH] sucht Nachrichten anhand eines Kriteriums. Es gibt etwa zwanzig solcher Kriterien. Hier suchen wir Nachrichten, die noch nicht gelesen wurden (UNSEEN). Der Server gibt ihre Nummern zurück: 1 und 2;
- [A4 FETCH 2 (...)]: Der Befehl [FETCH] fordert Informationen zu einer Nachricht an. Hier ruft er die Flags der Nachricht (FLAGS), ihre Größe (RFC822.SIZE) und vier ihrer Header ab. Das Format [BODY.PEEK[...]] fordert einen Teil der Nachricht an, ohne sie als gelesen zu markieren. Der Text der Header wird als Literal gesendet: [{114}] am Zeilenende zeigt an, dass die folgenden 114 Byte zur Antwort gehören, unabhängig von ihrem Inhalt (einschließlich Zeilenumbrüchen). Die Antwort endet nach dem Literal mit einer schließenden Klammer;
- [A5 FETCH 2 BODY.PEEK[1.1]]: Es wird Teil 1.1 der Nachricht Nr. 2 angefordert; hier ist sein Text [text/plain]. Wir sehen gleich, wie die Teile einer Nachricht nummeriert sind;
- [A6 FETCH 1 BODYSTRUCTURE]: Wir fordern die Struktur der Nachricht Nr. 1 an, derjenigen mit fünf Anhängen. Die Antwort ist eine Liste von Listen in Klammern. Wir erkennen die Teile der Nachricht wieder, die wir in [Mailpit] gesehen haben: eine Liste [(("text" "plain" ...)("text" "html" ...) "alternative" ...)] für den Teil [multipart/alternative], gefolgt von einer Liste für jeden Anhang, mit Typ, Parametern (Name), Kodierung (base64), Größe und Darstellung („attachment“ mit dem Dateinamen). Die Struktur endet mit dem Subtyp [mixed] der gesamten Nachricht;
- [A7 LOGOUT]: das Ende des Dialogs.
16.6.5. Klassen für die Protokolle POP3 und IMAP
Unsere Skripte zum Lesen von E-Mails verwenden wahlweise einen POP3-Server oder einen IMAP-Server. Wir schreiben daher:
- eine Schnittstelle [MailClient] , die beschreibt, was ein E-Mail-Client kann;
- eine abstrakte Klasse [TcpClient] , die das Gemeinsame beider Protokolle zusammenfasst: eine – gegebenenfalls verschlüsselte – TCP-Verbindung, über die Textzeilen ausgetauscht werden;
- zwei Klassen, [Pop3Client] und [ImapClient], die von [TcpClient] erben und die Schnittstelle [MailClient] implementieren;
- eine Klasse namens [MimePart] , die die Struktur einer Nachricht beschreibt, wie man sie über den IMAP-Befehl [BODYSTRUCTURE] erhält.
Sie befinden sich im Ordner [inet/imap]:
| imap
├── ImapClient.php
├── MailClient.php
├── MimePart.php
├── Pop3Client.php
├── TcpClient.php
├── config-imap-01.json
├── config-pop3-01.json
├── imap-01.php
├── imap-02.php
├── imap-03.php
└── pop3-01.php
|
16.6.5.1. Die Schnittstelle [MailClient]
| <?php
declare(strict_types=1);
// was ein Client zum Lesen von Mails können muss, ob er POP3 oder IMAP spricht
// die Nachrichten werden über ihre Nummer (1, 2...) im Postfach bezeichnet
interface MailClient
{
// Verbindung und Authentifizierung - gibt die Anzahl der Nachrichten im Postfach zurück
public function connect(): int;
// die Nummern der ungelesenen Nachrichten
public function unread(): array;
// die wichtigsten Header der Nachricht Nr. $n (Date, From, To, Subject...)
public function headers(int $n): array;
// der vollständige Text der Nachricht Nr. $n (Header und Body)
public function message(int $n): string;
// markiert die Nachricht Nr. $n als „zu löschen"
public function delete(int $n): void;
// löscht die markierten Nachrichten und schließt die Verbindung
public function close(): void;
}
|
- Zeile 10: Verbindung zum Server und Authentifizierung des Benutzers. Die Methode gibt die Anzahl der Nachrichten im Postfach zurück;
- Zeile 13: die Nummern der ungelesenen Nachrichten;
- Zeile 16: die wichtigsten Header einer Nachricht in Form eines Dictionarys;
- Zeile 19: der vollständige Text einer Nachricht, also das, was wir im Tab [Raw] von [Mailpit] gesehen haben;
- Zeile 22: markiert eine Nachricht als „zu löschen“;
- Zeile 25: löscht die markierten Nachrichten und schließt die Verbindung.
16.6.5.2. Die Klasse [TcpClient]
| <?php
declare(strict_types=1);
// Basisklasse der POP3- und IMAP-Clients: eine TCP-Verbindung, gegebenenfalls
// verschlüsselt (TLS), über die mit \r\n abgeschlossene Textzeilen ausgetauscht werden
abstract class TcpClient
{
// die Verbindung zum Server (eine Ressource vom Typ stream)
protected mixed $connection = null;
// $info: die Konfiguration des Servers (server, port, tls, verify-peer, user, password...)
// $tracking: wenn true, werden die Client-Server-Austausche auf der Konsole angezeigt
public function __construct(protected readonly array $info, protected readonly bool $tracking = false)
{
}
// Öffnen der Verbindung zum Server
protected function openConnection(): void
{
// Verbindung sofort beim Öffnen verschlüsselt (tls://) oder nicht (tcp://)?
$transport = ($this->info["tls"] ?? false) ? "tls" : "tcp";
// soll das Serverzertifikat geprüft werden? (standardmäßig ja)
$verify = $this->info["verify-peer"] ?? true;
$context = stream_context_create(["ssl" => ["verify_peer" => $verify, "verify_peer_name" => $verify]]);
$connection = @stream_socket_client("$transport://{$this->info["server"]}:{$this->info["port"]}",
$errorNumber, $error, 10, STREAM_CLIENT_CONNECT, $context);
if ($connection === false) {
throw new RuntimeException("failed to connect to the server "
. "[{$this->info["server"]}:{$this->info["port"]}]: $error");
}
$this->connection = $connection;
}
// Senden einer Zeile an den Server - $display: was im Tracking-Modus angezeigt werden soll
protected function send(string $line, ?string $display = null): void
{
fwrite($this->connection, "$line\r\n");
$this->display("--> " . ($display ?? $line));
}
// Lesen einer vom Server gesendeten Zeile, zurückgegeben ohne die Zeichen \r\n
// $display: soll die Zeile im Tracking-Modus angezeigt werden?
protected function readLine(bool $display = true): string
{
$line = fgets($this->connection);
if ($line === false) {
throw new RuntimeException("the server has closed the connection");
}
$line = rtrim($line, "\r\n");
if ($display) {
$this->display("<-- $line");
}
return $line;
}
// Lesen von $nbBytes vom Server gesendeten Bytes
protected function readBytes(int $nbBytes): string
{
$bytes = "";
while (strlen($bytes) < $nbBytes) {
$chunk = fread($this->connection, $nbBytes - strlen($bytes));
if ($chunk === false || $chunk === "") {
throw new RuntimeException("the server has closed the connection");
}
$bytes .= $chunk;
}
$this->display("<-- ... $nbBytes bytes ...");
return $bytes;
}
// Schließen der Verbindung
protected function closeConnection(): void
{
if ($this->connection !== null) {
fclose($this->connection);
$this->connection = null;
}
}
// Anzeige im Tracking-Modus
protected function display(string $message): void
{
if ($this->tracking) {
print "$message\n";
}
}
// Analyse der Header einer Nachricht: gibt das Dictionary [Name => Wert] der
// decodierten Header zurück (Header mit Nicht-ASCII-Zeichen sind codiert, zum Beispiel =?utf-8?Q?...?=)
protected static function parseHeaders(string $headers): array
{
$dictionary = iconv_mime_decode_headers($headers, ICONV_MIME_DECODE_CONTINUE_ON_ERROR, "UTF-8");
return $dictionary === false ? [] : $dictionary;
}
}
|
- Zeile 7: Die Klasse ist abstrakt; sie kann nicht instanziiert werden. Sie dient als Elternklasse der Klassen [Pop3Client] und [ImapClient];
- Zeile 10: Die Verbindung zum Server. Die Funktionen in PHP stellen sie als Ressource dar, einen Typ, der sich in PHP nicht deklarieren lässt: Daher wird der Typ [mixed] verwendet;
- Zeile 14: Der Konstruktor verwendet Constructor Property Promotion (PHP 8.0): Die Parameter [$info] und [$tracking] werden zu Eigenschaften der Klasse, hier schreibgeschützt ([readonly], PHP 8.1). Der Rumpf des Konstruktors ist leer. [$info] ist die Serverkonfiguration, die aus einer JSON-Datei gelesen wird. [$tracking] verlangt, dass die Austauschvorgänge zwischen Client und Server angezeigt werden;
- Zeilen 19–32: Aufbau der Verbindung. Enthält die Konfiguration [tls: true], wird die Verbindung verschlüsselt, sobald sie aufgebaut ist (Transport [tls://]). Der Kontext legt fest, ob das Zertifikat des Servers geprüft werden soll (Eintrag [verify-peer], standardmäßig true);
- Zeile 36: Senden einer Zeile an den Server. Der Parameter [$display] erlaubt es, etwas anderes anzuzeigen als das, was gesendet wird: Wir verwenden ihn, um Passwörter zu verbergen;
- Zeile 44: Lesen einer Zeile. Hat der Server die Verbindung geschlossen, wird eine Ausnahme ausgelöst;
- Zeile 58: liest eine bestimmte Anzahl von Bytes. Wir verwenden dies für die Literale in IMAP. Die Funktion [fread] kann weniger Bytes als angefordert zurückgeben: Wir wiederholen den Aufruf in einer Schleife, bis alles empfangen wurde;
- Zeile 91: Die Funktion [iconv_mime_decode_headers] parst einen Block von E-Mail-Headern und gibt das Dictionary [name => value] zurück. Sie fügt über mehrere Zeilen verteilte Header zusammen und dekodiert kodierte Header (=?utf-8?Q?...?=).
16.6.5.3. Die Klasse [Pop3Client]
| <?php
declare(strict_types=1);
require_once __DIR__ . "/TcpClient.php";
require_once __DIR__ . "/MailClient.php";
// POP3-Client: die Befehle USER, PASS, STAT, TOP, LIST, RETR, DELE, QUIT
final class Pop3Client extends TcpClient implements MailClient
{
// Anzahl der Nachrichten im Postfach
private int $nbMessages = 0;
#[\Override]
public function connect(): int
{
$this->openConnection();
// Willkommensnachricht des Servers
$this->command("");
// Authentifizierung
$this->command("USER {$this->info["user"]}");
$this->command("PASS {$this->info["password"]}", "PASS *****");
// STAT: die Antwort hat die Form [+OK nbMessages totalSize]
$response = $this->command("STAT");
$this->nbMessages = (int) explode(" ", $response[0])[1];
return $this->nbMessages;
}
#[\Override]
public function unread(): array
{
// POP3 merkt sich die gelesenen Nachrichten nicht: alle vorhandenen Nachrichten sind neu
return $this->nbMessages === 0 ? [] : range(1, $this->nbMessages);
}
#[\Override]
public function headers(int $n): array
{
// TOP n 0: die Header der Nachricht Nr. n gefolgt von 0 Zeilen des Bodys
$lines = $this->command("TOP $n 0", multiline: true);
$headers = self::parseHeaders(implode("\r\n", array_slice($lines, 1)));
// LIST n: die Antwort hat die Form [+OK n size]
$response = $this->command("LIST $n");
// wir behalten nur die wichtigsten Header
$summary = array_intersect_key($headers, array_flip(["Date", "From", "To", "Subject", "Message-ID"]));
return [...$summary, "Size" => explode(" ", $response[0])[2]];
}
#[\Override]
public function message(int $n): string
{
// RETR n: die 1. Zeile der Antwort ist [+OK...], die folgenden sind die Nachricht
$lines = $this->command("RETR $n", multiline: true);
return implode("\r\n", array_slice($lines, 1)) . "\r\n";
}
#[\Override]
public function delete(int $n): void
{
$this->command("DELE $n");
}
#[\Override]
public function close(): void
{
// nichts zu tun, wenn die Verbindung nicht geöffnet werden konnte
if ($this->connection === null) {
return;
}
try {
// der Befehl QUIT löscht die mit DELE markierten Nachrichten
$this->command("QUIT");
} finally {
$this->closeConnection();
}
}
// sendet einen Befehl an den Server (falls er nicht leer ist) und gibt die Zeilen der Antwort zurück
// $multiline: endet die Antwort mit einer Zeile, die nur aus einem Punkt besteht?
private function command(string $command, ?string $display = null, bool $multiline = false): array
{
if ($command !== "") {
$this->send($command, $display);
}
// 1. Zeile: +OK oder -ERR
$line = $this->readLine();
if (str_starts_with($line, "-ERR")) {
throw new RuntimeException("[" . ($display ?? $command) . "]: $line");
}
$response = [$line];
if ($multiline) {
// die folgenden Zeilen bis zur Zeile [.] werden im Tracking-Modus nicht angezeigt
while (($line = $this->readLine(false)) !== ".") {
// der Server verdoppelt den Punkt am Zeilenanfang: wir entfernen ihn
$response[] = str_starts_with($line, "..") ? substr($line, 1) : $line;
}
$this->display("<-- ... " . (count($response) - 1) . " lines ...");
$this->display("<-- .");
}
return $response;
}
}
|
- Zeile 9: Die Klasse erbt von [TcpClient] und implementiert [MailClient]. Sie ist als [final] deklariert: Von ihr können keine Klassen abgeleitet werden;
- Zeile 14: Das Attribut [#[\Override]] (PHP 8.3) zeigt an, dass die Methode eine Methode einer Schnittstelle implementiert oder eine Methode der Elternklasse überschreibt. Ist dies nicht der Fall (z. B. wegen eines Tippfehlers im Namen), meldet PHP einen Fehler;
- Zeilen 15–26: die Verbindung. Die Befehle aus [pop3-01.php] finden sich hier wieder. Der Befehl [STAT] gibt die Anzahl der Nachrichten und ihre Gesamtgröße in einer einzigen Zeile zurück. Das Passwort wird in der Form [*****] angezeigt;
- Zeilen 30–33: Das POP3-Protokoll führt nicht Buch über gelesene Nachrichten; alle Nachrichten werden als neu behandelt. Die Funktion [range(1, n)] gibt das Array [1, 2, ..., n] zurück;
- Zeilen 37–46: Der Befehl [TOP n 0] gibt die Header der Nachricht Nr. n gefolgt von 0 Zeilen ihres Textkörpers zurück. Der Befehl [LIST n] gibt ihre Größe zurück. Die Funktion [array_intersect_key] behält nur die Header, deren Namen Schlüssel des von [array_flip] zurückgegebenen Arrays sind. Der Operator [...] kopiert diese Header in das zurückgegebene Array, dem die Größe hinzugefügt wird;
- Zeilen 50–54: Der Befehl [RETR n] gibt die Nachricht Nr. n zurück;
- Zeilen 64–74: Der Befehl [QUIT] löscht die mit dem Befehl [DELE] markierten Nachrichten. Die Verbindung wird in allen Fällen geschlossen (Block [finally]);
- Zeile 80: Die Methode [command] entspricht der Funktion [sendCommand] aus [pop3-01.php]. Im Trace-Modus werden die Zeilen einer mehrzeiligen Antwort nicht angezeigt; es wird nur ihre Anzahl angegeben.
16.6.5.4. Die Klasse [ImapClient]
| <?php
declare(strict_types=1);
require_once __DIR__ . "/TcpClient.php";
require_once __DIR__ . "/MailClient.php";
require_once __DIR__ . "/MimePart.php";
// IMAP-Client: die Befehle LOGIN, SELECT, SEARCH, FETCH, STORE, EXPUNGE, LOGOUT
// jedem Befehl geht ein Tag voraus (A0001, A0002...); der Server sendet
// Antworten der Form [* ...] und beendet sie mit einer Antwort [tag OK|NO|BAD ...]
final class ImapClient extends TcpClient implements MailClient
{
// Nummer des zuletzt gesendeten Befehls (dient zum Bilden der Tags)
private int $number = 0;
// gibt es Nachrichten, die als „zu löschen" markiert sind?
private bool $deletions = false;
#[\Override]
public function connect(): int
{
$this->openConnection();
// Willkommensnachricht des Servers: [* OK ...]
[$welcome] = $this->readResponse();
if (!str_starts_with($welcome, "* OK")) {
throw new RuntimeException("the server refuses the connection: $welcome");
}
// Authentifizierung
$this->command("LOGIN " . self::quote($this->info["user"]) . " " . self::quote($this->info["password"]),
"LOGIN " . self::quote($this->info["user"]) . " *****");
// Auswahl des Postfachs: eine der Antworten hat die Form [* n EXISTS]
$responses = $this->command("SELECT " . self::quote($this->info["mailbox"] ?? "INBOX"));
$exists = array_find($responses, fn(array $response): bool => ($response[1] ?? "") === "EXISTS");
return (int) ($exists[0] ?? 0);
}
#[\Override]
public function unread(): array
{
// die Antwort hat die Form [* SEARCH n1 n2 ...]
$responses = $this->command("SEARCH UNSEEN");
$search = array_find($responses, fn(array $response): bool => $response[0] === "SEARCH") ?? ["SEARCH"];
return array_map(intval(...), array_slice($search, 1));
}
#[\Override]
public function headers(int $n): array
{
// BODY.PEEK[HEADER]: die Header der Nachricht, ohne sie als gelesen zu markieren
$data = $this->fetch($n, "(FLAGS RFC822.SIZE BODY.PEEK[HEADER])");
$headers = self::parseHeaders($data["BODY[HEADER]"]);
// wir behalten nur die wichtigsten Header
$summary = array_intersect_key($headers, array_flip(["Date", "From", "To", "Subject", "Message-ID"]));
return [...$summary, "Flags" => implode(" ", $data["FLAGS"]), "Size" => $data["RFC822.SIZE"]];
}
#[\Override]
public function message(int $n): string
{
// BODY[]: die gesamte Nachricht; der Server markiert sie als gelesen (Flag \Seen)
return $this->fetch($n, "BODY[]")["BODY[]"];
}
// die MIME-Struktur der Nachricht Nr. $n
public function structure(int $n): MimePart
{
return MimePart::fromBodyStructure($this->fetch($n, "BODYSTRUCTURE")["BODYSTRUCTURE"]);
}
// der (codierte) Inhalt des Teils Nr. $section (1, 1.2...) der Nachricht Nr. $n
public function part(int $n, string $section): string
{
return $this->fetch($n, "BODY[$section]")["BODY[$section]"] ?? "";
}
#[\Override]
public function delete(int $n): void
{
// wir fügen der Nachricht das Flag \Deleted hinzu
$this->command("STORE $n +FLAGS (\\Deleted)");
$this->deletions = true;
}
#[\Override]
public function close(): void
{
// nichts zu tun, wenn die Verbindung nicht geöffnet werden konnte
if ($this->connection === null) {
return;
}
try {
// EXPUNGE löscht die Nachrichten, die das Flag \Deleted haben
if ($this->deletions) {
$this->command("EXPUNGE");
}
$this->command("LOGOUT");
} finally {
$this->closeConnection();
}
}
// Befehl FETCH n items: gibt das Dictionary [item => value] der Antwort zurück
// [* n FETCH (item1 value1 item2 value2 ...)]
private function fetch(int $n, string $items): array
{
$responses = $this->command("FETCH $n $items");
$fetch = array_find($responses, fn(array $response): bool => ($response[1] ?? "") === "FETCH");
if ($fetch === null) {
throw new RuntimeException("no message no. $n");
}
$dictionary = [];
foreach (array_chunk($fetch[2], 2) as [$key, $value]) {
$dictionary[strtoupper($key)] = $value;
}
return $dictionary;
}
// sendet einen Befehl mit Tag und gibt seine Antworten der Form [* ...] zurück, jede in Tokens zerlegt
// $display: was im Tracking-Modus angezeigt werden soll (um ein Passwort zu verbergen)
private function command(string $command, ?string $display = null): array
{
$tag = sprintf("A%04d", ++$this->number);
$this->send("$tag $command", $display === null ? null : "$tag $display");
$responses = [];
while (true) {
[$text, $literals] = $this->readResponse();
// abschließende Antwort [tag OK|NO|BAD text]?
if (str_starts_with($text, "$tag ")) {
$status = substr($text, strlen($tag) + 1);
if (!str_starts_with($status, "OK")) {
throw new RuntimeException("[" . ($display ?? $command) . "]: $status");
}
return $responses;
}
// Antwort der Form [* ...]
if (str_starts_with($text, "* ")) {
$position = 2;
$responses[] = self::tokens($text, $position, $literals);
}
}
}
// liest eine Antwort des Servers: eine Zeile, die Literale enthalten kann. Ein Literal
// wird durch {n} am Zeilenende angekündigt: es folgen n Bytes, dann der Rest der Zeile.
// gibt den Text der Antwort zurück, in dem das Literal Nr. k durch \0k\0 ersetzt ist, sowie die Literale
private function readResponse(): array
{
$text = "";
$literals = [];
while (true) {
$line = $this->readLine();
if (preg_match('/\{(\d+)\}$/', $line, $fields) !== 1) {
return [$text . $line, $literals];
}
$text .= substr($line, 0, -strlen($fields[0])) . "\0" . count($literals) . "\0";
$literals[] = $this->readBytes((int) $fields[1]);
}
}
// zerlegt $text ab der Position $position in Tokens, bis zum Textende oder
// bis zu einer schließenden Klammer. Eine Liste (...) wird zu einem Array, NIL wird zu null,
// ein String "..." oder ein Literal wird zu einem String, alles andere (Atom) ebenfalls
private static function tokens(string $text, int &$position, array $literals): array
{
$tokens = [];
$length = strlen($text);
while ($position < $length) {
$c = $text[$position];
if ($c === " ") {
$position++;
} elseif ($c === "(") {
// eine Liste: rekursiver Aufruf
$position++;
$tokens[] = self::tokens($text, $position, $literals);
} elseif ($c === ")") {
// Ende der aktuellen Liste
$position++;
return $tokens;
} elseif ($c === '"') {
// ein String in Anführungszeichen, in dem \" und \\ für " und \ stehen
$string = "";
for ($position++; $text[$position] !== '"'; $position++) {
if ($text[$position] === "\\") {
$position++;
}
$string .= $text[$position];
}
$position++;
$tokens[] = $string;
} elseif ($c === "\0") {
// ein Literal
$end = strpos($text, "\0", $position + 1);
$tokens[] = $literals[(int) substr($text, $position + 1, $end - $position - 1)];
$position = $end + 1;
} else {
// ein Atom: bis zum nächsten Leerzeichen oder zur nächsten Klammer, außer innerhalb eckiger Klammern
// (BODY[HEADER.FIELDS (FROM TO)] ist ein einziges Atom)
$start = $position;
$brackets = 0;
while ($position < $length
&& ($brackets > 0 || !in_array($text[$position], [" ", "(", ")"], true))) {
$brackets += match ($text[$position]) { "[" => 1, "]" => -1, default => 0 };
$position++;
}
$atom = substr($text, $start, $position - $start);
$tokens[] = $atom === "NIL" ? null : $atom;
}
}
return $tokens;
}
// ein IMAP-String: zwischen Anführungszeichen, mit \ vor den Zeichen " und \
private static function quote(string $text): string
{
return '"' . addcslashes($text, '"\\') . '"';
}
}
|
- Zeile 15: die Nummer des letzten Befehls. Sie dient zur Erzeugung der Tags [A0001], [A0002] ...;
- Zeilen 20–34: Die Verbindung. Der Server sendet zunächst eine Willkommensnachricht: [* OK ...]. Anschließend werden die Befehle [LOGIN] und [SELECT] gesendet. Die Methode [command] gibt die Antworten [* ...] des Servers zurück, jeweils in Tokens zerlegt: Die Antwort [* 2 EXISTS] wird zum Array [["2", "EXISTS"]]. Die Funktion [array_find] (PHP 8.4) gibt das erste Element des Arrays zurück, das die Bedingung erfüllt, oder [null];
- Zeilen 38–43: der Befehl [SEARCH UNSEEN]. Das Ergebnis [* SEARCH 1 2] wird zu [["SEARCH", "1", "2"]]. Wir behalten die Elemente ab Nummer 1 ([array_slice]), die von der Funktion [intval] in Ganzzahlen umgewandelt werden. Die Schreibweise [intval(...)] (PHP 8.1) erzeugt aus der Funktion [intval] eine Funktion: Das ist die Syntax für First-Class-Callables;
- Zeilen 47–54: Der Befehl [FETCH n (FLAGS RFC822.SIZE BODY.PEEK[HEADER])] gibt Flags, Größe und Header der Nachricht Nr. n zurück;
- Zeilen 58–61: Der Befehl [FETCH n BODY[]] gibt die Nachricht Nr. n vollständig zurück. Der Server fügt ihr das Flag [\Seen] hinzu: Die Nachricht ist nun als gelesen markiert;
- Zeilen 65–67: Der Befehl [FETCH n BODYSTRUCTURE] gibt die Struktur der Nachricht zurück, die die Klasse [MimePart] in einen Objektbaum umwandelt;
- Zeilen 71–73: Der Befehl [FETCH n BODY[section]] gibt den Inhalt des Teils Nr. [section] der Nachricht zurück, so wie er in der Nachricht kodiert ist (Base64, quoted-printable usw.);
- Zeilen 77–81: Der Befehl [STORE n +FLAGS (\Deleted)] fügt der Nachricht das Flag [\Deleted] hinzu. Sie wurde noch nicht entfernt;
- Zeilen 85–98: Der Befehl [EXPUNGE] löscht Nachrichten, die das Flag [\Deleted] haben. Der Befehl [LOGOUT] beendet den Dialog;
- Zeilen 104–115: Die Methode [fetch] sendet einen Befehl [FETCH] und wandelt die Antwortliste [[* n FETCH (item1 value1 item2 value2...)]] in ein assoziatives Array [[item1 => value1, item2 => value2...]] um. Die Funktion [array_chunk] teilt die Liste in Paare auf, die die Schleife [foreach] in [[$key, $value]] zerlegt;
- Zeilen 120–133: Die Methode [command] sendet einen Befehl mit vorangestelltem Label und liest dann die Antworten des Servers, bis sie auf diejenige trifft, die mit dem Label beginnt. Ist diese letzte Antwort nicht [OK], wird eine Exception ausgelöst;
- Zeilen 146–153: Lesen einer Antwort. Endet eine Zeile mit [{n}], folgen darauf n Bytes (das Literal) und anschließend der Rest der Antwort. Im Antworttext wird jedes Literal durch einen Marker [\0k\0] ersetzt (\0 ist das Zeichen mit dem Code 0, das in einer IMAP-Textzeile nicht vorkommen kann), und sein Inhalt wird im Array [$literals] gespeichert;
- Zeilen 163–209: Die Methode [tokens] zerlegt den Text einer Antwort in Token:
- Eine in Klammern eingeschlossene Liste wird zu einem Array. Die Methode ruft sich selbst auf (rekursiver Aufruf), um den Inhalt der Liste zu analysieren, und gibt bei der schließenden Klammer die Kontrolle zurück;
- Eine in Anführungszeichen eingeschlossene Zeichenkette oder ein Literal wird zu einem String;
- [NIL] wird zu [null];
- Alles andere (ein Atom) wird zu einem String. Ein Atom kann eckige Klammern enthalten, die ihrerseits Leerzeichen und runde Klammern enthalten können: [BODY[HEADER.FIELDS (FROM TO)]] ist ein einziges Atom. Der Ausdruck [match] addiert 1 zum Zähler der geöffneten eckigen Klammern bei [[] und subtrahiert 1 davon bei []];
- Der per Referenz übergebene Parameter [$position] ist die aktuelle Position im Text: Sie rückt mit dem Fortschreiten der Analyse vor, auch innerhalb rekursiver Aufrufe;
- Zeile 213: Ein IMAP-String steht in Anführungszeichen. Die Funktion [addcslashes] setzt ein [\]-Zeichen vor die Zeichen ["] und [\].
16.6.5.5. Die Klasse [MimePart]
| <?php
declare(strict_types=1);
// ein Teil einer MIME-Nachricht, wie ihn die BODYSTRUCTURE-Antwort eines IMAP-Servers beschreibt
// eine Nachricht ist ein Baum von Teilen: ein Teil [multipart/xxx] hat Unterteile
final readonly class MimePart
{
public function __construct(
// MIME-Typ und -Untertyp in Kleinbuchstaben: text/plain, multipart/mixed, application/pdf...
public string $type,
public string $subType,
// Parameter des Typs, zum Beispiel [charset => utf-8]
public array $parameters = [],
// Codierung des Inhalts: 7bit, 8bit, base64, quoted-printable...
public string $encoding = "7bit",
// Disposition (attachment, inline) oder null und ihre Parameter, zum Beispiel [filename => x.pdf]
public ?string $disposition = null,
public array $dispositionParameters = [],
// die Unterteile eines Teils [multipart/xxx]
public array $parts = [],
) {
}
// baut den Baum der Teile aus der Liste der BODYSTRUCTURE-Tokens auf
public static function fromBodyStructure(array $structure): self
{
// mehrteiliger Teil: ((Unterteil 1) (Unterteil 2)... "Untertyp" (Parameter) Disposition...)
if (is_array($structure[0])) {
// die Unterteile sind die ersten Elemente, die Listen sind
$parts = [];
$i = 0;
while (is_array($structure[$i])) {
$parts[] = self::fromBodyStructure($structure[$i++]);
}
return new self(
type: "multipart",
subType: strtolower($structure[$i]),
parameters: self::dictionary($structure[$i + 1] ?? null),
disposition: self::disposition($structure[$i + 2] ?? null)[0],
dispositionParameters: self::disposition($structure[$i + 2] ?? null)[1],
parts: $parts,
);
}
// einfacher Teil: ("Typ" "Untertyp" (Parameter) id description "Codierung" size ...)
$type = strtolower($structure[0]);
$subType = strtolower($structure[1]);
// die Disposition steht nach Feldern, die vom Typ des Teils abhängen
$dispositionIndex = match (true) {
// text/xxx: ... size nbLines md5 disposition
$type === "text" => 9,
// message/rfc822: ... size envelope structure nbLines md5 disposition
$type === "message" && $subType === "rfc822" => 11,
// andere: ... size md5 disposition
default => 8,
};
[$disposition, $dispositionParameters] = self::disposition($structure[$dispositionIndex] ?? null);
return new self(
type: $type,
subType: $subType,
parameters: self::dictionary($structure[2]),
encoding: strtolower($structure[5] ?? "7bit"),
disposition: $disposition,
dispositionParameters: $dispositionParameters,
);
}
// der Dateiname eines Anhangs oder null
public function fileName(): ?string
{
// der Name ist der Parameter [filename] der Disposition oder, falls dieser fehlt, der Parameter [name]
// des Typs. Er kann auf zwei Arten codiert sein:
// - filename*=utf-8''Tah%C3%A9.png (RFC 2231);
// - name="=?utf-8?Q?Tah=C3=A9.png?=" (RFC 2047);
$encoded = $this->dispositionParameters["filename*"] ?? $this->parameters["name*"] ?? null;
if ($encoded !== null) {
// Zeichensatz''URL-codierter Name
[$charset, , $name] = explode("'", $encoded, 3);
return mb_convert_encoding(rawurldecode($name), "UTF-8", $charset);
}
$name = $this->dispositionParameters["filename"] ?? $this->parameters["name"] ?? null;
return $name === null ? null : iconv_mime_decode($name, ICONV_MIME_DECODE_CONTINUE_ON_ERROR, "UTF-8");
}
// eine IMAP-Liste (key1 value1 key2 value2...) oder NIL, in ein Dictionary umgewandelt
private static function dictionary(?array $list): array
{
$dictionary = [];
foreach (array_chunk($list ?? [], 2) as [$key, $value]) {
$dictionary[strtolower($key)] = $value;
}
return $dictionary;
}
// eine IMAP-Disposition ("attachment" (Parameter)) oder NIL: gibt [Disposition, Parameter] zurück
private static function disposition(mixed $disposition): array
{
if (!is_array($disposition)) {
return [null, []];
}
return [strtolower($disposition[0]), self::dictionary($disposition[1] ?? null)];
}
}
|
- Zeile 7: Eine Klasse [readonly] (PHP 8.2) hat ausschließlich schreibgeschützte Eigenschaften: Nach der Konstruktion kann ein Objekt [MimePart] nicht mehr verändert werden;
- Zeilen 9–22: Alle Eigenschaften werden durch Promotion der Konstruktorparameter deklariert. Sie haben Standardwerte, sodass nur bestimmte Parameter per Name übergeben werden können (benannte Argumente);
- Zeile 26: Die statische Methode [fromBodyStructure] erstellt den Teilebaum aus der Token-Liste der Antwort [BODYSTRUCTURE];
- Zeilen 29–42: Ein mehrteiliger Part beginnt mit den Listen seiner Unterteile, von denen jeder durch einen rekursiven Aufruf in ein Objekt [MimePart] umgewandelt wird. Danach folgen sein Untertyp (mixed, alternative usw.), seine Parameter (boundary) und seine Disposition;
- Zeilen 45–57: Ein einfacher Part beginnt mit seinem Typ, Untertyp, seinen Parametern, einer Kennung, einer Beschreibung, seiner Kodierung und seiner Größe. Die Position der Disposition hängt vom Typ des Parts ab: Ein Part [text/xxx] enthält zusätzlich eine Zeilenzahl; ein Part [message/rfc822] enthält zusätzlich den Umschlag und die Struktur der Nachricht sowie eine Zeilenzahl. Der Ausdruck [match (true)] wählt den ersten Zweig, dessen Bedingung wahr ist;
- Zeilen 69–82: der Dateiname eines Anhangs. Wir haben in [Mailpit] gesehen, dass er auf zwei Arten kodiert sein kann:
- die Kodierung nach RFC 2231 [utf-8''Tah%C3%A9.png]: der Zeichensatz, zwei Apostrophe, gefolgt vom Namen, kodiert wie in einer URL. Er wird mit [rawurldecode] dekodiert und anschließend mit [mb_convert_encoding] in UTF-8 umgewandelt;
- die Kodierung nach RFC 2047 [=?utf-8?Q?Tah=C3=A9.png?=]: Dekodieren Sie sie mit der Funktion [iconv_mime_decode];
- Zeile 86: Eine IMAP-Liste [("charset" "utf-8")] wird zum assoziativen Array [["charset" => "utf-8"]];
- Zeile 96: eine Disposition [("attachment" ("filename" "x.pdf"))] wird zum Array [["attachment", ["filename" => "x.pdf"]]].
16.6.6. POP3-/IMAP-Client [imap-01.php]
Das Skript [imap-01.php] hat denselben Zweck wie das gleichnamige Skript aus dem Kurs PHP 7, das die Funktionen [imap_open], [imap_num_msg], [imap_search], [imap_headerinfo], [imap_body], [imap_delete], [imap_expunge] und [imap_close] verwendete. Es nutzt die folgende JSON-Datei [config-imap-01.json]:
| {
"imap.gmail.com:993": {
"enabled": false,
"protocol": "imap",
"server": "imap.gmail.com",
"port": 993,
"tls": true,
"verify-peer": true,
"user": "php8parlexemple@gmail.com",
"password": "application password",
"mailbox": "INBOX",
"output-dir": "output/gmail-imap"
},
"localhost:993": {
"protocol": "imap",
"server": "localhost",
"port": 993,
"tls": true,
"verify-peer": false,
"user": "guest@localhost",
"password": "guest",
"mailbox": "INBOX",
"output-dir": "output/localhost-imap"
},
"localhost:1110": {
"protocol": "pop3",
"server": "localhost",
"port": 1110,
"tls": false,
"user": "guest",
"password": "guest",
"output-dir": "output/localhost-pop3"
}
}
|
Die Datei [config-imap-01.json] definiert ein assoziatives Array der IMAP-/POP3-Server, die kontaktiert werden sollen. Jeder Eintrag hat die Form [key => value], wobei gilt:
- [key]: ist ein Name, der den Server bezeichnet. Hier haben wir drei:
- [imap.gmail.com:993]: der IMAP-Server von Gmail, der Port 993 mit verschlüsselter Verbindung abhört. Er ist deaktiviert ([enabled] steht auf [false]): Tragen Sie dort Ihre Gmail-Adresse und Ihr App-Passwort ein und setzen Sie dann [enabled] auf [true];
- [localhost:993]: der lokale IMAP-Server mit einer Verbindung, die durch ein selbstsigniertes Zertifikat verschlüsselt ist, das nicht überprüft wird;
- [localhost:1110]: der POP3-Server von [Mailpit];
- [value]: ist ein assoziatives Array, das die folgenden Punkte festlegt:
- [protocol]: das Protokoll, [imap] oder [pop3];
- [server]: der Name des IMAP- oder POP3-Servers;
- [port]: der Port des Servers (IMAP oder POP3);
- [tls]: Ist die Verbindung verschlüsselt?
- [verify-peer]: Soll das Serverzertifikat überprüft werden? Wenn die Überprüfung unter Windows bei einem öffentlichen Server fehlschlägt, prüfen Sie, ob die Direktive [openssl.cafile] in der Datei [php.ini] auf eine Datei einer Zertifizierungsstelle verweist, wie es bei [Laragon] der Fall ist;
- [user]: der Besitzer des Postfachs;
- [password]: das Passwort des Postfachbesitzers;
- [mailbox]: das zu lesende IMAP-Postfach, wobei INBOX dasjenige ist, in dem neue Nachrichten eingehen;
- [output-dir]: der Ordner, in dem die Nachrichten gespeichert werden sollen.
Beim POP3-Protokoll wird eine Nachricht nach dem Lesen gelöscht. So arbeiten POP3-Server üblicherweise: Eine gelesene Nachricht wird nicht auf dem Server aufbewahrt.
Das Skript [imap-01.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// IMAP-Client (Internet Message Access Protocol) / POP3-Client zum Lesen von Mails
// die zu lesenden Postfächer sind in einer Konfigurationsdatei beschrieben
require_once __DIR__ . "/ImapClient.php";
require_once __DIR__ . "/Pop3Client.php";
// die Parameter zum Lesen der Mails
const CONFIG_FILE_NAME = "config-imap-01.json";
// Anzeige der Client-Server-Austausche?
const TRACKING = false;
// wir rufen die Konfiguration ab
$mailboxes = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// Lesen der Postfächer
foreach ($mailboxes as $name => $info) {
// Postfach in der Konfiguration deaktiviert?
if (($info["enabled"] ?? true) === false) {
print "------------Mailbox [$name] disabled\n";
continue;
}
// Nachverfolgung
print "------------Reading the mailbox [$name]\n";
// Lesen des Postfachs
readmailbox($name, $info);
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function createClient(array $info): MailClient
{
// ein IMAP- oder POP3-Client, je nach Konfiguration
return match ($info["protocol"]) {
"imap" => new ImapClient($info, TRACKING),
"pop3" => new Pop3Client($info, TRACKING),
};
}
// --------------------------------------------------------------------------
function readmailbox(string $name, array $info): void
{
// der Client des Postfachs
$client = createClient($info);
try {
// Verbindung
$nbmsg = $client->connect();
print "Connection established with the server [$name].\n";
// Gesamtzahl der Nachrichten im Postfach
print "There are [$nbmsg] messages in the mailbox [$name]\n";
if ($nbmsg === 0) {
return;
}
// ungelesene Nachrichten im Postfach
print "Retrieving the list of the unread messages of the mailbox [$name]\n";
$msgNumbers = $client->unread();
if (count($msgNumbers) === 0) {
print "There are no new messages in the mailbox [$name]\n";
return;
}
foreach ($msgNumbers as $msgNumber) {
// wir rufen die Header der Nachricht Nr. $msgNumber ab
print "Headers of the message no. [$msgNumber] of the mailbox [$name]\n";
print_r($client->headers($msgNumber));
// wir rufen den vollständigen Text der Nachricht Nr. $msgNumber ab und speichern ihn
saveMessage($client->message($msgNumber), $msgNumber, $info);
// wenn das Protokoll POP3 ist, löschen wir die Nachricht
if ($info["protocol"] === "pop3") {
$client->delete($msgNumber);
}
}
} catch (RuntimeException $ex) {
print "Error: " . $ex->getMessage() . "\n";
} finally {
// in jedem Fall schließen wir die Verbindung
try {
$client->close();
print "Connection closed successfully.\n";
} catch (RuntimeException $ex) {
print "Closing the connection failed: " . $ex->getMessage() . "\n";
}
}
}
// --------------------------------------------------------------------------
function saveMessage(string $message, int $msgNumber, array $info): void
{
// die Nachricht wird in der Datei [output-dir/message-N.eml] gespeichert
$fileName = "{$info["output-dir"]}/message-$msgNumber.eml";
print "Saving the message in the file [$fileName]\n";
// wir erstellen bei Bedarf den Ordner (true: mit seinen übergeordneten Ordnern)
if (!is_dir($info["output-dir"])) {
mkdir($info["output-dir"], recursive: true);
}
// wir speichern die Nachricht
if (file_put_contents($fileName, $message) === false) {
print "Saving failed\n";
}
}
|
Kommentare:
- Zeilen 8–9: Die Klassen beider Clients werden geladen, die ihrerseits die Klasse [TcpClient] und die Schnittstelle [MailClient] laden;
- Zeile 14: Bei [true] werden die Client-Server-Austausche angezeigt. Probieren Sie es aus;
- Zeilen 20–29: Wir durchlaufen alle in der Konfigurationsdatei gefundenen Server, mit Ausnahme der deaktivierten;
- Zeilen 35–41: Die Funktion [createClient] gibt je nach Konfiguration einen IMAP- oder POP3-Client zurück. Ihr Rückgabetyp ist die Schnittstelle [MailClient]: Der Rest des Skripts weiß nicht, mit welchem Protokoll er es zu tun hat. Das ist Polymorphie;
- Zeile 51: Verbindung und Authentifizierung;
- Zeile 60: die Nummern der ungelesenen Nachrichten;
- Zeile 68: Die Header der Nachricht werden mit der Funktion [print_r] angezeigt;
- Zeile 70: Der vollständige Text der Nachricht wird in einer Datei gespeichert;
- Zeile 72: Beim POP3-Protokoll wird die Nachricht zum Löschen markiert;
- Zeilen 78–86: In jedem Fall wird die Verbindung geschlossen, wodurch die markierten Nachrichten gelöscht werden. Wenn die Anweisungen [return] im Block [try] ausgeführt werden, wird auch der Block [finally] ausgeführt;
- Zeile 97: Die Funktion [mkdir] erstellt den Ordner samt seinen übergeordneten Ordnern, und zwar mit dem benannten Argument [recursive: true].
Führen wir das Skript [smtp-02.php] aus, damit der Benutzer [guest@localhost] neue Nachrichten hat. Anschließend führen wir das Skript [imap-01.php] aus, um die Postfächer zu lesen. Die Konsolenausgabe lautet wie folgt:
| > php imap-01.php
------------Mailbox [imap.gmail.com:993] disabled
------------Reading the mailbox [localhost:993]
Connection established with the server [localhost:993].
There are [2] messages in the mailbox [localhost:993]
Retrieving the list of the unread messages of the mailbox [localhost:993]
Headers of the message no. [1] of the mailbox [localhost:993]
Array
(
[From] => guest@localhost
[To] => guest@localhost
[Subject] => test-localhost
[Message-ID] => <b80fff003b5b37b74244dc69674f3ce4@localhost>
[Date] => Thu, 01 Oct 2026 17:14:39 +0200
[Flags] =>
[Size] => 259683
)
Saving the message in the file [output/localhost-imap/message-1.eml]
Headers of the message no. [2] of the mailbox [localhost:993]
Array
(
[From] => guest@localhost
[To] => guest@localhost
[Subject] => test-secure-server
[Message-ID] => <759bf5367e3f1136ce964ded7f702e09@localhost>
[Date] => Thu, 01 Oct 2026 17:14:39 +0200
[Flags] =>
[Size] => 28101
)
Saving the message in the file [output/localhost-imap/message-2.eml]
Connection closed successfully.
------------Reading the mailbox [localhost:1110]
Connection established with the server [localhost:1110].
There are [2] messages in the mailbox [localhost:1110]
Retrieving the list of the unread messages of the mailbox [localhost:1110]
Headers of the message no. [1] of the mailbox [localhost:1110]
Array
(
[From] => guest@localhost
[To] => guest@localhost
[Subject] => test-secure-server
[Message-ID] => <759bf5367e3f1136ce964ded7f702e09@localhost>
[Date] => Thu, 01 Oct 2026 17:14:39 +0200
[Size] => 28101
)
Saving the message in the file [output/localhost-pop3/message-1.eml]
Headers of the message no. [2] of the mailbox [localhost:1110]
Array
(
[From] => guest@localhost
[To] => guest@localhost
[Subject] => test-localhost
[Message-ID] => <b80fff003b5b37b74244dc69674f3ce4@localhost>
[Date] => Thu, 01 Oct 2026 17:14:39 +0200
[Size] => 259683
)
Saving the message in the file [output/localhost-pop3/message-2.eml]
Connection closed successfully.
Done
|
- Bei IMAP werden die beiden im Postfach INBOX abgelegten Nachrichten gelesen. Die Flags [Flags] sind leer: Die Nachrichten wurden noch nicht gelesen;
- bei POP3 finden wir dieselben Nachrichten im Postfach [Mailpit] in umgekehrter Reihenfolge. Die gelesenen Nachrichten werden gelöscht.
Wenn wir das Skript [imap-01.php] anschließend sofort erneut ausführen, sehen die Ergebnisse wie folgt aus:
| > php imap-01.php
------------Mailbox [imap.gmail.com:993] disabled
------------Reading the mailbox [localhost:993]
Connection established with the server [localhost:993].
There are [2] messages in the mailbox [localhost:993]
Retrieving the list of the unread messages of the mailbox [localhost:993]
There are no new messages in the mailbox [localhost:993]
Connection closed successfully.
------------Reading the mailbox [localhost:1110]
Connection established with the server [localhost:1110].
There are [0] messages in the mailbox [localhost:1110]
Connection closed successfully.
Done
|
- Im IMAP-Postfach befindet sich weiterhin dieselbe Anzahl von Nachrichten, es gibt aber keine ungelesenen mehr. Das zeigt, dass die vorherige Ausführung den Status der gelesenen Nachrichten von „ungelesen“ auf „gelesen“ gesetzt hat (Flag [\Seen]);
- Im POP3-Posteingang befinden sich keine Nachrichten mehr: Sie wurden bei der vorherigen Ausführung gelöscht.
Die Nachrichten wurden lokal in den Ordnern [output/localhost-imap] und [output/localhost-pop3] unter den Namen [message-1.eml] und [message-2.eml] gespeichert. Die Dateierweiterung [.eml] wird für E-Mail-Dateien verwendet: Ein Doppelklick auf eine dieser Dateien öffnet sie im E-Mail-Client von Windows. Der Inhalt der Datei besteht aus dem vollständigen Text der Nachricht, wie wir ihn im Reiter [Raw] von [Mailpit] gesehen haben: Der Nachrichtentext und die kodierten Inhalte der Anhänge sind dort miteinander vermischt.
Versuchen wir, dieses Skript so zu verbessern, dass die verschiedenen Teile der Nachricht und die Anhänge in getrennten Dateien gespeichert werden.
16.6.7. Verbesserter IMAP-Client ([imap-02.php])
Der IMAP-Server kann uns die Struktur einer Nachricht (Befehl [BODYSTRUCTURE]) und anschließend den Inhalt jedes ihrer Teile (Befehl [FETCH n BODY[section]]) liefern. Das nutzen wir im Skript [imap-02.php]. Das POP3-Protokoll kennt dagegen nur die gesamte Nachricht: Das Skript verarbeitet daher nur die IMAP-Postfächer.
Greifen wir noch einmal die Antwort auf den Befehl [BODYSTRUCTURE] auf, die wir beim Kennenlernen des IMAP-Protokolls erhalten haben. Sie beschreibt eine Nachricht vom Typ [multipart/mixed] mit sechs Teilen:
- Der erste Teil hat den Typ [multipart/alternative]. Er hat selbst zwei Unterteile: [text/plain] und [text/html], kodiert in [quoted-printable] und mit dem Parameter [charset=utf-8];
- die nächsten fünf Teile sind die Anhänge, kodiert als [base64], jeweils mit der Disposition [attachment] und einem Dateinamen.
Die Teile werden wie folgt nummeriert:
- die gesamte Nachricht vom Typ [multipart/mixed] hat keine Nummer. Ihre Teile werden mit 1, 2... nummeriert;
- Hat ein Teil Unterteile, werden diese mit x.1, x.2... nummeriert, wobei x die Nummer des umschließenden Teils ist. So ist der Text [text/plain] der Nachricht der Teil Nr. 1.1: Es ist derjenige, den wir mit dem Befehl [FETCH 2 BODY.PEEK[1.1]] angefordert haben.
Das Skript [imap-02.php] lautet wie folgt:
| <?php
declare(strict_types=1);
// IMAP-Client, der die Texte und die Anhänge der ungelesenen Nachrichten getrennt speichert
// er verwendet die vom IMAP-Server gelieferte MIME-Struktur der Nachrichten (Befehl BODYSTRUCTURE)
require_once __DIR__ . "/ImapClient.php";
// die Parameter zum Lesen der Mails
const CONFIG_FILE_NAME = "config-imap-01.json";
// wir rufen die Konfiguration ab
$mailboxes = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// Lesen der Postfächer
foreach ($mailboxes as $name => $info) {
// uns interessieren nur die aktiven IMAP-Postfächer
if (($info["enabled"] ?? true) === false || $info["protocol"] !== "imap") {
continue;
}
print "------------Reading the mailbox [$name]\n";
readmailbox($name, $info);
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function readmailbox(string $name, array $info): void
{
$client = new ImapClient($info);
try {
// Verbindung
$nbmsg = $client->connect();
print "Connection established with the server [$name].\n";
print "There are [$nbmsg] messages in the mailbox [$name]\n";
// ungelesene Nachrichten
print "Retrieving the list of the unread messages of the mailbox [$name]\n";
$msgNumbers = $client->unread();
if (count($msgNumbers) === 0) {
print "There are no new messages in the mailbox [$name]\n";
}
foreach ($msgNumbers as $msgNumber) {
// die Header der Nachricht dienen als Präfix für ihre Texte
$headers = $client->headers($msgNumber);
// die Struktur der Nachricht
$structure = $client->structure($msgNumber);
// wir durchlaufen ihre Teile
$outputDir = "{$info["output-dir"]}/message-$msgNumber";
getParts($client, $msgNumber, $structure, "", $outputDir, $headers);
}
} catch (RuntimeException $ex) {
print "Error: " . $ex->getMessage() . "\n";
} finally {
try {
$client->close();
print "Connection closed successfully.\n";
} catch (RuntimeException $ex) {
print "Closing the connection failed: " . $ex->getMessage() . "\n";
}
}
}
// --------------------------------------------------------------------------
function getParts(ImapClient $client, int $msgNumber, MimePart $part, string $section,
string $outputDir, array $headers): void
{
// zeigt den Typ des Teils [$part] der Nachricht Nr. $msgNumber an und dann:
// - hat er Unterteile, werden diese der Reihe nach verarbeitet (rekursiver Aufruf);
// - andernfalls wird er im Ordner [$outputDir] gespeichert
// $section ist die IMAP-Nummer des Teils: 1, 2, 1.1, 1.2...
// der Wurzelteil (die gesamte Nachricht) hat keine Nummer: wir zeigen 0 an
print "-----content of the part no. [" . ($section === "" ? "0" : $section) . "]\n";
print "Content-Type: " . strtoupper("$part->type/$part->subType") . "\n";
print "Transfer-Encoding: $part->encoding\n";
// Unterteile?
if ($part->type === "multipart") {
foreach ($part->parts as $i => $subpart) {
// die Unterteile des Teils Nr. x sind mit x.1, x.2... nummeriert
$subsection = $section === "" ? (string) ($i + 1) : "$section." . ($i + 1);
getParts($client, $msgNumber, $subpart, $subsection, $outputDir, $headers);
}
return;
}
// eine Nachricht, die nicht mehrteilig ist, hat einen einzigen Teil mit der Nummer 1
if ($section === "") {
$section = "1";
}
// wir speichern den Teil
savePart($client, $msgNumber, $part, $section, $outputDir, $headers);
}
// --------------------------------------------------------------------------
function savePart(ImapClient $client, int $msgNumber, MimePart $part, string $section,
string $outputDir, array $headers): void
{
// wenn der Ordner nicht existiert, erstellen wir ihn
if (!is_dir($outputDir)) {
mkdir($outputDir, recursive: true);
}
// ein Anhang?
$fileName = $part->fileName();
if ($part->disposition === "attachment" && $fileName !== null) {
saveAttachment($client->part($msgNumber, $section), $part, "$outputDir/$fileName");
return;
}
// ein Text?
match ("$part->type/$part->subType") {
"text/plain" => saveText("$outputDir/message.txt", false,
$client->part($msgNumber, $section), $part, $headers),
"text/html" => saveText("$outputDir/message.html", true,
$client->part($msgNumber, $section), $part, $headers),
// andere Fälle: dieser Teil wird nicht verarbeitet
default => print "Part [$section] ignored\n",
};
}
// --------------------------------------------------------------------------
function decode(string $text, string $encoding): string
{
// Decodierung eines in base64 oder quoted-printable codierten Inhalts
return match ($encoding) {
"base64" => base64_decode($text),
"quoted-printable" => quoted_printable_decode($text),
// 7bit, 8bit, binary: keine Codierung
default => $text,
};
}
// --------------------------------------------------------------------------
function saveText(string $fileName, bool $html, string $text, MimePart $part, array $headers): void
{
// der Text wird decodiert und dann nach UTF-8 konvertiert, wenn er einen anderen Zeichensatz verwendet
$text = decode($text, $part->encoding);
$charset = $part->parameters["charset"] ?? "utf-8";
if (strtolower($charset) !== "utf-8") {
$text = mb_convert_encoding($text, "UTF-8", $charset);
}
// wir stellen ihm die Header From, To, Subject der Nachricht voran
$endOfLine = $html ? "<br/>\n" : "\n";
$content = "From: {$headers["From"]}$endOfLine"
. "To: {$headers["To"]}$endOfLine"
. "Subject: {$headers["Subject"]}$endOfLine$endOfLine"
. $text;
print "Saving a message in [$fileName]\n";
if (file_put_contents($fileName, $content) === false) {
print "Unable to create the file [$fileName]\n";
}
}
// --------------------------------------------------------------------------
function saveAttachment(string $content, MimePart $part, string $fileName): void
{
print "Saving the attachment in [$fileName]\n";
if (file_put_contents($fileName, decode($content, $part->encoding)) === false) {
print "The attachment could not be saved in [$fileName]\n";
}
}
|
Kommentare:
- Zeile 19: Es werden nur aktive IMAP-Postfächer gelesen;
- Zeile 45: Die Header der Nachricht werden dem gespeicherten Text vorangestellt;
- Zeile 47: die Struktur der Nachricht: ein Objekt [MimePart];
- Zeile 50: Die Funktion [getParts] durchläuft die Teile der Nachricht. Sie beginnt mit dem Wurzelteil – der gesamten Nachricht –, der keine Abschnittsnummer hat;
- Zeile 65: Die Funktion [getParts] erhält die folgenden Parameter:
- [$client]: der IMAP-Client;
- [$msgNumber]: die Nummer der Nachricht, deren Teile angefordert werden;
- [$part]: ein Objekt, das einen Teil der Nachricht darstellt;
- [$section]: die Nummer dieses Teils;
- [$outputDir]: der Ordner, in dem die Teile gespeichert werden sollen;
- [$headers]: allgemeine Informationen zur E-Mail (Absender, Empfänger, Betreff usw.);
- Zeilen 73–75: Die Nummer, der Inhaltstyp und die Kodierung des Teils werden angezeigt. Die gesamte Nachricht wird als Teil Nummer 0 angezeigt;
- Zeilen 77–83: Hat der Teil Unterteile, wird jeder von ihnen durch einen rekursiven Aufruf der Funktion [getParts] abgerufen. Ihre Abschnittsnummer ist [$section.i];
- Zeilen 86–87: Eine Nachricht, die nicht mehrteilig ist (reiner Text), hat nur einen Teil mit der Nummer 1;
- Zeile 90: Gibt es keine Unterteile, wird der Inhalt des Teils gespeichert;
- Zeile 94: Die Funktion [savePart] speichert einen Teil:
- Handelt es sich um einen Anhang (Einstellung [attachment]), wird er mit der Funktion [saveAttachment] unter seinem Dateinamen gespeichert;
- Ist der Text vom Typ [text/plain] oder [text/html], wird er mit der Funktion [saveText] in der Datei [message.txt] bzw. [message.html] gespeichert. Die übrigen Teile werden ignoriert;
- in beiden Fällen wird der Inhalt des Abschnitts mit der Methode [part] des Clients beim IMAP-Server angefordert;
- Zeile 119: Der Inhalt eines Abschnitts ist kodiert. Die Funktionen [base64_decode] und [quoted_printable_decode] dekodieren ihn;
- Zeile 131: Der Text wird dekodiert und anschließend mit der Funktion [mb_convert_encoding] in UTF-8 umgewandelt, falls er einen anderen Zeichensatz verwendet (Parameter [charset]). Ihm werden die Nachrichten-Header [From], [To] und [Subject] vorangestellt. Bei HTML-Text folgt auf jeden Header ein Tag [<br/>], damit er in einem Browser in einer eigenen Zeile erscheint;
- Zeile 152: Ein Anhang wird dekodiert und anschließend gespeichert.
Um das Skript [imap-02.php] zu testen, senden Sie zunächst eine E-Mail an [guest@localhost] mit dem Skript [smtp-02.php] (die Nachricht [test-localhost] mit ihren fünf Anhängen), die im Postfach INBOX auf dem IMAP-Server abgelegt wird. Anschließend wird sie mit [imap-02.php] gelesen. Die Konsolenausgabe lautet wie folgt:
| > php imap-02.php
------------Reading the mailbox [localhost:993]
Connection established with the server [localhost:993].
There are [3] messages in the mailbox [localhost:993]
Retrieving the list of the unread messages of the mailbox [localhost:993]
-----content of the part no. [0]
Content-Type: MULTIPART/MIXED
Transfer-Encoding: 7bit
-----content of the part no. [1]
Content-Type: MULTIPART/ALTERNATIVE
Transfer-Encoding: 7bit
-----content of the part no. [1.1]
Content-Type: TEXT/PLAIN
Transfer-Encoding: quoted-printable
Saving a message in [output/localhost-imap/message-3/message.txt]
-----content of the part no. [1.2]
Content-Type: TEXT/HTML
Transfer-Encoding: quoted-printable
Saving a message in [output/localhost-imap/message-3/message.html]
-----content of the part no. [2]
Content-Type: APPLICATION/VND.OPENXMLFORMATS-OFFICEDOCUMENT.WORDPROCESSINGML.DOCUMENT
Transfer-Encoding: base64
Saving the attachment in [output/localhost-imap/message-3/Hello from Symfony Mailer.docx]
-----content of the part no. [3]
Content-Type: APPLICATION/PDF
Transfer-Encoding: base64
Saving the attachment in [output/localhost-imap/message-3/Hello from Symfony Mailer.pdf]
-----content of the part no. [4]
Content-Type: APPLICATION/VND.OASIS.OPENDOCUMENT.TEXT
Transfer-Encoding: base64
Saving the attachment in [output/localhost-imap/message-3/Hello from Symfony Mailer.odt]
-----content of the part no. [5]
Content-Type: IMAGE/PNG
Transfer-Encoding: base64
Saving the attachment in [output/localhost-imap/message-3/Cours-Tutoriels-Serge-Tahé-1568x268.png]
-----content of the part no. [6]
Content-Type: MESSAGE/RFC822
Transfer-Encoding: base64
Saving the attachment in [output/localhost-imap/message-3/test-localhost.eml]
Connection closed successfully.
Done
|
Die Struktur der Nachricht bleibt korrekt erhalten. Die Dateien wurden im Ordner [output/localhost-imap/message-3] gespeichert:
| message-3
├── Cours-Tutoriels-Serge-Tahé-1568x268.png
├── Hello from Symfony Mailer.docx
├── Hello from Symfony Mailer.odt
├── Hello from Symfony Mailer.pdf
├── message.html
├── message.txt
└── test-localhost.eml
|
Die Word-Dokumente, das PDF, das OpenOffice-Dokument und das Bild lassen sich normal öffnen: Sie wurden korrekt dekodiert.
Die angehängte Nachricht [test-localhost.eml] wurde als Anhang gespeichert. Sie ist jedoch selbst eine E-Mail, die ihrerseits Text und Anhänge enthält. Beachten Sie in der Antwort [BODYSTRUCTURE] , dass der Server diese angehängte Nachricht nicht analysieren konnte, weil sie in Base64 kodiert ist: Er liefert einen leeren Umschlag ([(NIL NIL ...)]) und eine auf leeren Text reduzierte Struktur. Um weiterzukommen, müssten wir die angehängte Nachricht herunterladen, dekodieren und ihre Struktur (MIME) selbst analysieren. Und diese Nachricht könnte ihrerseits eine angehängte E-Mail enthalten, und so weiter. Anstatt diesen Parser von Grund auf zu schreiben, verwenden wir eine Bibliothek.
16.6.8. POP3-/IMAP-Client mit der Bibliothek [zbateson/mail-mime-parser]
Der Kurs PHP 7 verwendete die Bibliothek [php-mime-mail-parser], die PHP und die Erweiterung [mailparse] benötigte, welche separat heruntergeladen und installiert werden musste. Wir verwenden die Bibliothek [zbateson/mail-mime-parser] (https://github.com/zbateson/mail-mime-parser), die vollständig in PHP geschrieben ist: Sie wurde zusammen mit den übrigen Abhängigkeiten des Kurses durch den Befehl [composer install] installiert, ohne dass weitere Schritte nötig sind. Sie analysiert den vollständigen Text einer Nachricht, wie ihn die Befehle [RETR] bei POP3 und [FETCH n BODY[]] bei IMAP liefern. Das Skript [imap-03.php] funktioniert somit mit beiden Protokollen.
Um es zu testen, senden wir eine Nachricht, deren letzter Anhang [test-localhost-2.eml], selbst einen E-Mail-Anhang enthält, [test-localhost.eml]:
- [test-localhost-2.eml] enthält 4 Anhänge (die Word-Dokumente, das PDF, das OpenOffice-Dokument und das Bild) sowie die E-Mail [test-localhost.eml];
- [test-localhost.eml] enthält dieselben 4 Anhänge.
Die Konfigurationsdatei [config-smtp-03.json] beschreibt diese E-Mail:
| {
"mail to localhost via localhost": {
"smtp-server": "localhost",
"smtp-port": 1025,
"from": "guest@localhost",
"to": "guest@localhost",
"subject": "test-localhost-3",
"message": "line 1\nline 2\nline 3",
"tls": false,
"attachments": [
"/attachments/Hello from Symfony Mailer.docx",
"/attachments/Hello from Symfony Mailer.pdf",
"/attachments/Hello from Symfony Mailer.odt",
"/attachments/Cours-Tutoriels-Serge-Tahé-1568x268.png",
"/attachments/test-localhost-2.eml"
]
}
}
|
Sie wird mit dem Befehl [php smtp-02.php config-smtp-03.json] verwendet.
Das Skript [imap-03.php] verwendet dieselbe Konfigurationsdatei, [config-imap-01.json], wie die vorherigen Skripte. Es lautet wie folgt:
| <?php
declare(strict_types=1);
// IMAP- / POP3-Client zum Lesen von Mails
// die Analyse der Nachrichten übernimmt die Bibliothek [zbateson/mail-mime-parser]
// verfügbar unter der URL [https://github.com/zbateson/mail-mime-parser]
// Abhängigkeiten
require_once __DIR__ . "/../../../vendor/autoload.php";
require_once __DIR__ . "/ImapClient.php";
require_once __DIR__ . "/Pop3Client.php";
use ZBateson\MailMimeParser\IMessage;
use ZBateson\MailMimeParser\Message;
// die Parameter zum Lesen der Mails
const CONFIG_FILE_NAME = "config-imap-01.json";
// wir rufen die Konfiguration ab
if (!file_exists(CONFIG_FILE_NAME)) {
print "The configuration file " . CONFIG_FILE_NAME . " does not exist\n";
exit(1);
}
$mailboxes = json_decode(file_get_contents(CONFIG_FILE_NAME), true);
// Lesen der Postfächer
foreach ($mailboxes as $name => $info) {
if (($info["enabled"] ?? true) === false) {
continue;
}
print "------------Reading the mailbox [$name]\n";
readmailbox($name, $info);
}
// Ende
print "Done\n";
// --------------------------------------------------------------------------
function readmailbox(string $name, array $info): void
{
// ein IMAP- oder POP3-Client, je nach Konfiguration
$client = match ($info["protocol"]) {
"imap" => new ImapClient($info),
"pop3" => new Pop3Client($info),
};
try {
// Verbindung
$nbmsg = $client->connect();
print "Connection established with the server [$name].\n";
print "There are [$nbmsg] messages in the mailbox [$name]\n";
// ungelesene Nachrichten
print "Retrieving the list of the unread messages of the mailbox [$name]\n";
$msgNumbers = $client->unread();
if (count($msgNumbers) === 0) {
print "There are no new messages in the mailbox [$name]\n";
}
// wir durchlaufen die Liste der ungelesenen Nachrichten
foreach ($msgNumbers as $msgNumber) {
print "---message no. [$msgNumber]\n";
// wir rufen den vollständigen Text der Nachricht ab und analysieren ihn
getMailBody($client->message($msgNumber), "{$info["output-dir"]}/message-$msgNumber");
// wenn das Protokoll POP3 ist, löschen wir die Nachricht nach dem Abrufen
if ($info["protocol"] === "pop3") {
$client->delete($msgNumber);
}
}
} catch (RuntimeException $ex) {
print "Error: " . $ex->getMessage() . "\n";
} finally {
try {
$client->close();
print "Connection closed successfully.\n";
} catch (RuntimeException $ex) {
print "Closing the connection failed: " . $ex->getMessage() . "\n";
}
}
}
// --------------------------------------------------------------------------
// Analyse des vollständigen Textes einer Nachricht
function getMailBody(string $text, string $outputDir): void
{
// die Bibliothek analysiert den Text der Nachricht und wandelt ihn in ein Objekt [IMessage] um
// (false: der Text wird nach dem Aufbau des Objekts nicht mehr benötigt)
$message = Message::from($text, false);
// wir speichern die verschiedenen Teile der Nachricht im Ordner [$outputDir]
getParts($message, $outputDir);
}
// --------------------------------------------------------------------------
// Speichern der verschiedenen Teile einer Nachricht
function getParts(IMessage $message, string $outputDir): void
{
// wir erstellen bei Bedarf den Ordner, in dem die Nachricht gespeichert wird
if (!is_dir($outputDir) && !mkdir($outputDir, recursive: true)) {
print "The folder [$outputDir] could not be created\n";
return;
}
// die Header der Nachricht (from, to, subject...), decodiert
$headers = [];
foreach ($message->getAllHeaders() as $header) {
$headers[] = "{$header->getName()}: {$header->getValue()}";
}
// wir speichern die Textnachrichten
for ($i = 1; $i <= $message->getTextPartCount(); $i++) {
print "-- Saving a message of type [text/plain]\n";
saveMessage($message->getTextContent($i - 1), false, $headers, "$outputDir/message_$i.txt");
}
// wir speichern die HTML-Nachrichten
for ($i = 1; $i <= $message->getHtmlPartCount(); $i++) {
print "-- Saving a message of type [text/html]\n";
saveMessage($message->getHtmlContent($i - 1), true, $headers, "$outputDir/message_$i.html");
}
// wir durchlaufen die Liste der Anhänge
$iAttachment = 0;
foreach ($message->getAllAttachmentParts() as $attachment) {
// Typ und Name des Anhangs
$fileType = $attachment->getContentType();
$fileName = freeName($outputDir, $attachment->getFilename() ?? "attachment");
print "-- Saving an attachment of type [$fileType] in the file [$fileName]\n";
// wir speichern den Anhang, decodiert
$attachment->saveContent($fileName);
// Sonderfall des Typs message/rfc822
if ($fileType === "message/rfc822") {
// der Anhang ist selbst eine Nachricht - wir analysieren ihn rekursiv
// in einem Unterordner [rfc822-1], [rfc822-2]...
$iAttachment++;
$attachedMessage = Message::from($attachment->getBinaryContentStream()->getContents(), false);
getParts($attachedMessage, "$outputDir/rfc822-$iAttachment");
}
}
}
// --------------------------------------------------------------------------
// ein freier Dateiname im Ordner [$dir]: x.pdf, andernfalls x_1.pdf, x_2.pdf...
function freeName(string $dir, string $name): string
{
$info = pathinfo($name);
$extension = isset($info["extension"]) ? ".{$info["extension"]}" : "";
$candidate = "$dir/$name";
for ($i = 1; file_exists($candidate); $i++) {
$candidate = "$dir/{$info["filename"]}_$i$extension";
}
return $candidate;
}
// --------------------------------------------------------------------------
// Speichern einer Textnachricht, der die Header der Nachricht vorangestellt sind
function saveMessage(string $text, bool $html, array $headers, string $filename): void
{
// in HTML wird jeder Header mit <br/> abgeschlossen, damit er allein in seiner Zeile steht
$endOfLine = $html ? "<br/>\n" : "\n";
$contents = implode($endOfLine, $headers) . $endOfLine . $endOfLine . $text;
if (file_put_contents($filename, $contents) === false) {
print "The message could not be saved in the file [$filename]\n";
} else {
print "The message has been saved in the file [$filename]\n";
}
}
|
Kommentare:
- Zeile 10: der Composer-Klassenlader für die Bibliothek [zbateson/mail-mime-parser];
- Zeilen 14–15: Die beiden Typen der Bibliothek, die wir verwenden: die Schnittstelle [IMessage] und die Klasse [Message], die sie implementiert;
- Zeile 21: Wir prüfen, ob die Konfigurationsdatei existiert;
- Zeile 39: Die Funktion [readmailbox] hat dieselbe Struktur wie in [imap-01.php]. Der IMAP- oder POP3-Client wird diesmal direkt durch einen Ausdruck [match] erzeugt;
- Zeile 61: Der vollständige Nachrichtentext wird von der Funktion [getMailBody] angefordert;
- Zeilen 81–87: Die statische Methode [Message::from] analysiert den Nachrichtentext und gibt ein Objekt [IMessage] zurück. Die Funktion [getParts] speichert dann seine verschiedenen Teile;
- Zeile 92: Die Funktion [getParts] hat zwei Parameter:
- die zu analysierende Nachricht [$message] ;
- [$outputDir]: der Ordner, in dem der Text und die Anhänge der Nachricht gespeichert werden sollen;
- Zeilen 101–102: Die Header der analysierten Nachricht (from, to, subject usw.) werden abgerufen. Die Methode [getValue] gibt den dekodierten Wert eines Headers zurück;
- Zeilen 105–107: Eine Nachricht kann mehrere Teile haben ([text/plain]). Die Methode [getTextContent($i - 1)] gibt den Text des i-ten Teils zurück (die Teile werden ab 0 nummeriert), dekodiert und in UTF-8 umgewandelt. Wir speichern sie alle und geben jedem einen anderen Dateinamen;
- Zeilen 110–112: dasselbe Vorgehen für die Teile [text/html];
- Zeile 116: Wir durchlaufen die Liste der Anhänge der Nachricht;
- Zeilen 118–119: der Typ des Anhangs (Header Content-Type) und sein Name, den die Bibliothek unabhängig von seiner Kodierung dekodiert. Die Funktion [freeName] gibt einen Dateinamen zurück, der im Ordner noch nicht existiert;
- Zeile 122: Die Methode [saveContent] speichert den dekodierten Inhalt des Anhangs in einer Datei;
- Zeilen 124–129: Ist der Anhang eine E-Mail, wird sie ihrerseits durch einen rekursiven Aufruf der Funktion [getParts] analysiert. Ihr dekodierter Inhalt wird mit der Methode [getBinaryContentStream] ermittelt, die einen Stream zurückgibt; der gesamte Inhalt dieses Streams wird dann mit der Methode [getContents] gelesen. Hat die analysierte Nachricht zwei E-Mail-Anhänge, wird der erste im Ordner [$outputDir/rfc822-1] und der zweite im Ordner [$outputDir/rfc822-2] gespeichert;
- Zeile 136: Existiert die Datei [x.pdf] bereits, probiert die Funktion [freeName] die Namen [x_1.pdf], [x_2.pdf]... aus, bis sie einen nicht vorhandenen Dateinamen findet. Die Funktion [pathinfo] zerlegt einen Dateinamen in Namen und Erweiterung;
- Zeile 149: Die Funktion [saveMessage] speichert den Nachrichtentext, dem die Header der Nachricht vorangestellt sind. Bei HTML-Text endet jeder Header mit dem Tag [<br/>].
Wir senden die Nachricht mit dem Befehl [php smtp-02.php config-smtp-03.json]. [Mailpit] speichert sie, und wir legen sie außerdem im Postfach INBOX auf dem IMAP-Server ab. Dann führen wir das Skript [imap-03.php] aus. Die Konsolenausgabe lautet wie folgt:
| > php imap-03.php
------------Reading the mailbox [localhost:993]
Connection established with the server [localhost:993].
There are [4] messages in the mailbox [localhost:993]
Retrieving the list of the unread messages of the mailbox [localhost:993]
---message no. [4]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-imap/message-4/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-imap/message-4/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-imap/message-4/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-imap/message-4/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-imap/message-4/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-imap/message-4/Cours-Tutoriels-Serge-Tahé-1568x268.png]
-- Saving an attachment of type [message/rfc822] in the file [output/localhost-imap/message-4/test-localhost-2.eml]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-imap/message-4/rfc822-1/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-imap/message-4/rfc822-1/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-imap/message-4/rfc822-1/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-imap/message-4/rfc822-1/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-imap/message-4/rfc822-1/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-imap/message-4/rfc822-1/Cours-Tutoriels-Serge-Tahé-1568x268.png]
-- Saving an attachment of type [message/rfc822] in the file [output/localhost-imap/message-4/rfc822-1/test-localhost.eml]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-imap/message-4/rfc822-1/rfc822-1/Cours-Tutoriels-Serge-Tahé-1568x268.png]
Connection closed successfully.
------------Reading the mailbox [localhost:1110]
Connection established with the server [localhost:1110].
There are [1] messages in the mailbox [localhost:1110]
Retrieving the list of the unread messages of the mailbox [localhost:1110]
---message no. [1]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-pop3/message-1/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-pop3/message-1/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-pop3/message-1/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-pop3/message-1/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-pop3/message-1/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-pop3/message-1/Cours-Tutoriels-Serge-Tahé-1568x268.png]
-- Saving an attachment of type [message/rfc822] in the file [output/localhost-pop3/message-1/test-localhost-2.eml]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-pop3/message-1/rfc822-1/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-pop3/message-1/rfc822-1/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-pop3/message-1/rfc822-1/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-pop3/message-1/rfc822-1/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-pop3/message-1/rfc822-1/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-pop3/message-1/rfc822-1/Cours-Tutoriels-Serge-Tahé-1568x268.png]
-- Saving an attachment of type [message/rfc822] in the file [output/localhost-pop3/message-1/rfc822-1/test-localhost.eml]
-- Saving a message of type [text/plain]
The message has been saved in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/message_1.txt]
-- Saving a message of type [text/html]
The message has been saved in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/message_1.html]
-- Saving an attachment of type [application/vnd.openxmlformats-officedocument.wordprocessingml.document] in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/Hello from Symfony Mailer.docx]
-- Saving an attachment of type [application/pdf] in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/Hello from Symfony Mailer.pdf]
-- Saving an attachment of type [application/vnd.oasis.opendocument.text] in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/Hello from Symfony Mailer.odt]
-- Saving an attachment of type [image/png] in the file [output/localhost-pop3/message-1/rfc822-1/rfc822-1/Cours-Tutoriels-Serge-Tahé-1568x268.png]
Connection closed successfully.
Done
|
Die Nachricht wurde zweimal gelesen – zuerst über IMAP und dann über POP3 – und ihre Teile wurden jeweils gespeichert. Hier ist die Verzeichnisstruktur des Ordners [output/localhost-imap/message-4]:
| message-4
├── rfc822-1
│ ├── rfc822-1
│ │ ├── Cours-Tutoriels-Serge-Tahé-1568x268.png
│ │ ├── Hello from Symfony Mailer.docx
│ │ ├── Hello from Symfony Mailer.odt
│ │ ├── Hello from Symfony Mailer.pdf
│ │ ├── message_1.html
│ │ └── message_1.txt
│ ├── Cours-Tutoriels-Serge-Tahé-1568x268.png
│ ├── Hello from Symfony Mailer.docx
│ ├── Hello from Symfony Mailer.odt
│ ├── Hello from Symfony Mailer.pdf
│ ├── message_1.html
│ ├── message_1.txt
│ └── test-localhost.eml
├── Cours-Tutoriels-Serge-Tahé-1568x268.png
├── Hello from Symfony Mailer.docx
├── Hello from Symfony Mailer.odt
├── Hello from Symfony Mailer.pdf
├── message_1.html
├── message_1.txt
└── test-localhost-2.eml
|
- auf der obersten Ebene der Text und die 5 Anhänge der E-Mail, die [guest@localhost] erhalten hat;
- im Ordner [rfc822-1] der Nachrichtentext und die 5 Anhänge der E-Mail [test-localhost-2.eml];
- im Ordner [rfc822-1/rfc822-1] der Text und die 4 Anhänge der E-Mail [test-localhost.eml].
Wenn Sie die Datei [rfc822-1/rfc822-1/message_1.html] in einem Browser öffnen, sehen Sie Folgendes:

Sie enthält die Header der E-Mail [test-localhost.eml], gefolgt von ihrem Nachrichtentext, wobei Umlaute und Akzente korrekt dekodiert sind.
Die Verwendung der Bibliothek [zbateson/mail-mime-parser] erleichtert das Schreiben des Skripts zum Lesen von E-Mails erheblich.