Bevor wir auf das zwar praktischere, aber auch etwas komplexere Beispiel des Webservers kommen, möchten wir die Grundlangen erneut anhand eines simplen Telnet-Beispiels veranschaulichen. Der Einfachheit halber haben wir den alten Server mit der Erweiterung _old.php den Quellcodes auf der CD beigelegt. Bei unserem ursprünglichen Beispiel wurde der Server zunächst mit PHP gestartet:

1. ./socketserver_old.php oder aber php -q socketserver_old.php

Anschließend konnte man per Telnet (telnet 192.168.1.1 31337) eine Verbindung zu diesem Server aufbauen und Zeichenketten mittels Tastatur eingeben, die der Server auf der Konsole ausgegeben hat. Mit quit konnte man die Verbindung des Clients beenden, mit shutdown konnte man sogar den Socket-Server herunterfahren. Der zweite Parameter der Funktion socket_listen() kennzeichnet die Anzahl jener Verbindungen, die in einer Warteschlange warten können. Wird die aktuelle Verbindung zum Client beendet, so kann der nächste Client in dieser Warteschlange mit dem Server kommunizieren.
Bei unserem Telnet-Beispiel bedeutet dies aber Folgendes: Lässt man die erste Verbindung des Clients bestehen und baut parallel dazu eine weitere Verbindung zum Socket-Server auf, so müssten der zweite Client und auch weitere Clients warten. Erst nachdem der erste Client mittels quit beendet wird, kann der nächste Client Textnachrichten an den Server senden, der diese Nachrichten darauf ausgibt.

Parallele Verarbeitung

Neben dem herkömmlichen Weg, einzelne Verbindungsanfragen nacheinander per socket_accept() abzuarbeiten, gibt es noch eine weitere Möglichkeit in PHP, Anfragen zu verarbeiten. Hierbei kommt die Funktion socket_select() zum Einsatz, die es ermöglicht, mehrere Anfragen gleichzeitig zu handeln. Die Funktion selbst überwacht dabei verschiedene Sockets auf Veränderung. Als Parameter nimmt sie mehrere Arrays entgegen, die für einzelne Anfragetypen zur Verfügung stehen. Es werden also Sockets in diesen einzelnen Arrays abgelegt. Erfahrene C-Programmierer werden diese Arrays schnell wiedererkennen, denn in C verwendet man so genannte FD-Sets (File Descriptor Sets) für jeden Anfragetyp anstelle von Arrays. Um aber ein Variablenchaos zu vermeiden, hat man sich entschieden, in PHP Arrays zu verwenden. Folgende Arrays werden im socket_select()-Aufruf benötigt:

• read array - Dieses Array enthält nach dem Aufruf von socket_select() nur noch die Socket-Verbindungen, auf denen bei einem Lesevorgang mindestens ein Byte an Daten zurückkam. Sockets, auf denen keine Leseverbindungen stattfanden, werden hieraus entfernt.
• write array - Dieses Array enthält die Socket-Verbindungen, auf denen ein Schreibvorgang stattgefunden hat.
• except array - In diesem Array sind die Sockets enthalten, bei denen während des Lese- beziehungsweise Schreibvorgangs ein Fehler aufgetreten ist.

Auch socket_select() kann den Skriptablauf blockieren. Man kann daher als vierten und fünften Parameter optional der Funktion auch noch einen Timeout in Sekunden beziehungsweise Millisekunden angeben.

Listing 1

1. #!/usr/local/bin/php -q
2. <?php
4. $ipaddress = '192.168.1.1';
5. $port = 31339;
6. // Ressourcen-arrays definieren
7. $readSocks = array();
8. // write und exception sockets werden in diesem script nicht benötigt
9. $writeSocks = null;
10. $exceptSocks = null;
11. // hier kommen alle neuen socket-verbindungen mit den clients hinein
12. $clients = array();
13. // erzeugen des sockets mittels socket_create()
14. $socket = socket_create(AF_INET, SOCK_STREAM, 0);
15. if ($socket === false) {
16. die('Fehler beim erzeugen des Sockets! Grund: ' . socket_strerror($socket) . "\n");
17. }
18. // socket an gegebene IP-Addresse und port binden.
19. if (($ret = socket_bind($socket, $ipaddress, $port)) === false) {
20. die('Fehler beim Binden des Sockets! Grund: ' . socket_strerror($ret) . "\n");
21. }
22. // auf dem socket auf einkommende verbindungen warten
23. if (($ret = socket_listen($socket, 5)) === false) {
24. die('Fehler beim lauschen auf dem Socket! Grund: ' . socket_strerror($ret) . "\n");
25. }
27. // einkommende Verbindung annehmen.
28. while (true) {
29. // der hauptsocket gehört ebenfalls zu den lesesockets
30. $readSocks = array();
31. $readSocks[] = $socket;
33. foreach($clients as $clientSock) {
34. $readSocks[] = $clientSock;
35. }
37. if (false === ($num_changed = socket_select($readSocks, $writeSocks, $exceptSocks, 0))) {
38. die('Fehler bei socket_select! Grund:' . socket_strerror(socket_last_error()) . "\n");
39. } elseif ($num_changed > 0) {
40. if (in_array($socket, $readSocks)) {
41. // Wenn unser socket immer noch in den lesesockets ist, hat
42. // ein neuer connect stattgefunden
43. if (($newsocket = socket_accept($socket)) === false) {
44. die('Fehler beim akzeptieren der Verbindung! Grund:' . socket_strerror($newsocket) . "\n");
45. } else {
46. // neuen client in die liste aller clienten aufnehmen
47. $clients[] = $newsocket;
48. }
49. }
51. foreach ($clients as $clientSock) {
52. if (in_array($clientSock, $readSocks)) {
53. // Ein Client hat uns daten geschickt.
54. $buffer = socket_read($clientSock, 2048);
55. if (!$buffer = trim($buffer)) {
56. // Verbindung wurde von der gegenpartei beendet.
57. socket_shutdown($clientSock);
58. socket_close($clientSock);
59. $key_index = array_keys(array_keys($clients), $clientSock);
60. array_splice($clients,$key_index[0]);
61. break;
62. }
63. if ($buffer == 'quit') {
64. // Verbindung möchte von der gegenstelle beendet werden.
65. socket_shutdown($clientSock);
66. socket_close($clientSock);
67. $key_index = array_keys(array_keys($clients), $clientSock);
68. array_splice($clients,$key_index[0]);
69. break;
70. } else {
71. // Normale nachricht
72. echo 'Nachricht von ' . $clientSock . ': ' . $buffer . "\n";
73. }
74. }
75. }
76. }
77. }
78. // Socket vor dem beenden schliessen
79. socket_shutdown($socket);
80. socket_close($socket);

Im Listing 1 befindet sich der geänderte Socket-Server. Dieser hat sich im Grunde nicht viel gegenüber der ursprünglichen Version geändert. Neben IP-Adresse und Port des Servers definieren wir zu Beginn die drei genannten Arrays (Lese-, Schreib- und Fehlerarray). Da wir in unserem Beispiel nur vom Lesearray Gebrauch machen, können wir die anderen mit NULL initialisieren. Des Weiteren wird ein Array angelegt, in dem sich später die Sockets aller aktuell verbundenen Clients befinden.
Anschließend erzeugen wir unseren Hauptsocket, binden ihn an die vorher definierte Adresse und warten auf Verbindungen mittels socket_listen(). In der Endlosschleife ist nun die wichtige Änderung gegenüber der Vorversion: Das Annehmen einkommender Verbindungen wird jetzt anders verarbeitet. Dem Anfang der Schleife schenken wir etwas später Beachtung. Interessant ist zunächst der Aufruf von socket_select(), der unsere drei Arrays verändert. Nach dem Aufruf befinden sich nur noch jene Sockets in den Arrays, bei denen eine Veränderung stattgefunden hat. socket_select() liefert bei einem Fehler FALSE zurück. Im Erfolgsfall wird jedoch ein Integerwert zurückgegeben, der die Anzahl der geänderten Verbindungen kennzeichnet. Da der Rückgabewert entweder vom Typ boolean - also TRUE oder FALSE - oder aber vom Typ integer sein kann, benutzen wir in der If-Anweisung den typenbasierenden Operator ===. Mit in_array() wird geprüft, ob sich unser ursprünglicher Socket ($socket) in dem Lesearray befindet. In diesem Spezialfall, wurde eine neue Verbindung zum Server geöffenet. Also verwenden wir hier socket_accept() und erhalten in $newsocket unseren Connected Socket. Diesen neuen Socket fügen wir dem Array $clients hinzu. Darin werden alle Sockets jener Clients gehalten, zu denen unser Server eine offene Verbindung hat.
Im zweiten Teil der Schleife gehen wir das Array $clients mit einer foreach-Schleife durch, also alle aktuellen Verbindungen. Da wir aber nur jene Sockets verarbeiten möchten, wo eine Veränderung stattgefunden hat, prüfen wir nach, ob sich der jeweils aktuelle $clientSock in der foreach-Schleife auch in dem Lesearray befindet. In diesem sind dank socket_select() nur noch veränderte Sockets vorhanden.
Wird nun eine Verbindung beendet oder übermittelt der Client die Zeichenfolge quit, so beenden wir den Socket wie gehabt mittels socket_shutdown() und socket_close(). Weiterhin lassen wir uns mit array_keys() den Index dieses Sockets in $key_index zurückgeben, um das geschlossene Socket aus dem Array der aktuellen Clients zu entfernen. Falls die Verbindung nicht beendet werden soll, geben wir die übermittelte Zeichenfolge an der Konsole aus. Der shutdown-Befehl würde bei diesem neuen Server keinen Sinn machen. Er würde den Socket-Server herunterfahren, was bei paralleler Verarbeitung der Verbindung unerwünscht ist.
Der Anfang der while-Schleife wird nun selbsterklärend. Wir erzeugen hier das Lesearray neu, da es von socket_select() manipuliert wird. Unseren Hauptarray fügen wir ebenfalls dem Lesearray hinzu. Falls dieses später nach dem Aufruf von socket_select() noch vorhanden ist, so kennzeichnet das wie besprochen einen neuen Verbindungsaufbau. Die foreach-Schleife im Anschluss fügt nun noch alle Sockets aus $clients dem Lesearray hinzu. Falls also auf einer der aktuellen Verbindungen eine Aktivität stattgefunden hat, überleben die Sockets dieser Verbindungen den Aufruf von socket_select() und die Kommunikation kann verarbeitet werden.

HTTP Server revisited

Werden auf dem ursprünglichen HTTP Server parallele Verbindungen geöffnet, so kann nur eine verarbeitet werden. Alle übrigen Verbindungen werden verworfen. Um so genannte Concurrency zu testen, kann man beispielsweise das Benchmarktool von Apache ab (Apache Benchmark) verwenden, das auf jedem System vorhanden ist, auf dem der Apache Webserver installiert wurde.
Im ersten Durchlauf benutzen wir noch den alten Server, der als class.httpserver_old.php der CD beigelegt ist, und lassen ab (Apache Benchmark) laufen:

1. ab http://192.168.1.1:12345/ -c 1000 -n 1000

Der Parameter -c kennzeichnet die Anzahl der parallelen Zugriffe. Das Ergebnis schwankt abhängig von Hardware und Durchlauf. Da jedoch nur ein Socket die Anfragen abarbeitet, viele Sockets somit in der Warteschlange warten und auch einige Verbindungen verworfen werden, dauert der Test ziemlich lange:

1. Server Software:        PHPHTTPD/1.0
2. Server Hostname:        192.168.1.1
3. Server Port:            12345
4. Document Path:          /
5. Document Length:        7 bytes
6. Concurrency Level:      1000
7. Time taken for tests:   62.988 seconds

Lässt man nun den neuen HTTP Server laufen, so kann man eine Veränderung von ca. 50 Sekunden (von ca. 63 s auf 11 s) feststellen:

1. Server Software:        PHPHTTPD/1.0
2. Server Hostname:        192.168.1.1
3. Server Port:            12346
4. Document Path:          /
5. Document Length:        7 bytes
6. Concurrency Level:      1000
7. Time taken for tests:   10.090 seconds

Würde man nicht nur eine ganz kleine einfache HTML-Seite ausgeben, würden die Unterschiede noch größer sein, abhängig von der Abarbeitung der Seite.

Listing 2

1. function loop () {
3. // Read array neu initialisieren
4. unset($this->read);
5. $this->read = array();
6. $this->read[] = $this->socket;
7. reset($this->clients);
8. foreach ( $this->clients as $clientSocket ) {
9. $this->read[] = $clientSocket;
10. }
11. if (($num_changed = @socket_select($this->read, $this->write, $this->except, 0)) === FALSE ) {
12. echo 'Fehler bei socket_select! Grund: '.socket_strerror(socket_lasterror())."\n";
13. return FALSE;
14. } elseif ( $num_changed > 0 ) {
16. if(in_array($this->socket, $this->read)) {
17. if ( ($clientsocket = socket_accept($this -> socket)) === FALSE ) {
18. echo 'Fehler beim akzeptieren der Verbindung! Grund:'.socket_strerror($clientsocket)."\n";
19. return FALSE;
20. } else {
21. $this->clients[] = $clientsocket;
22. }
23. }
25. // Jeden einzelnen client-request verarbeiten
26. foreach($this->clients as $clientSocket ) {
27. if (in_array($clientSocket, $this->read)) {
29. // Neue nachricht auf dem Socket
30. $buffer = socket_read ( $clientSocket, 1024 );
31. if ( !$buffer = trim($buffer) ) {
32. echo "Fehler beim lesen auf dem Socket\n";
33. $key_index = array_keys(array_keys($this->clients), $clientSocket);
34. array_splice($this->clients,$key_index[0]);
35. socket_close($clientSocket);
36. return TRUE;
37. } else {
39. // Nachricht verarbeiten und antwort erzeugen
40. $answer = $this->handleClientRequest( $buffer );
42. // Daten an den Client-Socket senden
43. socket_write($clientSocket, $answer, strlen($answer));
45. // Verbindung zum Client wieder schließen
46. socket_close($clientSocket);
48. // Client aus dem clients-array entfernen
49. $key_index = array_keys(array_keys($this->clients), $clientSocket);
50. array_splice($this->clients,$key_index[0]);
51. }
52. }
53. }
54. }
55. return TRUE;
56. }

Die Verarbeitung der Verbindungen unseres Webservers findet in der Methode loop() statt (Listing 2). Anstatt hier wie gehabt direkt mittels socket_accept() einen Connected Socket zu erzeugen, verwenden wir die Socket-Arrays. Der Quellcode hierzu (Listing 2) ist analog zu dem Telnet-Beispiel aufgebaut. Die verwendeten Arrays werden hier nicht lokal gehalten, sondern sind Attribute der Klasse bzw. des Objekts.
Zunächst wird das Lesearray reinitialisiert. Anschließend werden Hauptsocket und alle aktuellen Verbindungssockets dem Lesearray hinzugefügt. socket_select() filtert jene Sockets heraus, auf denen seit dem letzten Schleifendurchgang keine Veränderung stattgefunden hat. Falls eine neue Verbindung stattgefunden hat, wird dies dem Clients-Array hinzugefügt, worauf all die Sockets darin durchlaufen werden. Unsere HTTP-Anfrage wird wie auch in der ersten Version von der Methode handleClientRequest() verarbeitet. Das angeforderte Dokument wird mit socket_write() an den jeweiligen Socket geschrieben. Anders aber als bei unserem Telnet-Beispiel schließen wir darauf explizit die Verbindung, da HTTP ein zustandsloses Protokoll ist (vergleiche Teil 1 des Artikels). Um das aktuelle Socket beim nächsten Durchgang nicht mehr unter den aktiven Client-Sockets zu haben, entfernen wir mithilfe von array_splice() diesen Socket aus dem $clients-Array. Dies geschieht wiederum analog zum Telnet-Beispiel.

Fazit

Ab der Version 4.3 kann die Socket-Erweiterung eingesetzt werden, ohne API-Änderungen befürchten zu müssen. Wie unser zweiteiliger Artikel zeigte, kann man nicht nur einfache Verbindungen mit PHP meistern. Die Implementierung der FD-Sets in ihrer speziellen Form in PHP macht es leicht, auch jenen Anforderungen gerecht zu werden, bei denen die gleichzeitige Verarbeitung von Sockets notwendig ist.
Verglichen mit unserem ersten Teil, war dieser zweite Teil etwas theoretischer und abstrakter. Wir hoffen dennoch, dass er Spaß gemacht hat und lehrreich war.
Marcel Beerta arbeitet als Softwareentwickler für die Innovative Software AG in Frankfurt/Main. Er ist Spezialist bei der Erstellung von Applikationen im Bereich des Online Brokering. Zudem ist er Entwickler des freien Chats Mazen's PHP Chat (www.mazenphp.de), der auf den Socket-Erweiterungen von PHP basiert.
Richard Samar (richard-samar.de) ist freiberuflicher Berater und Softwarearchitekt und wohnt in der Nähe von Frankfurt/Main. Seit vielen Jahren ist er PHP-Enthusiast und der deutschsprachigen PHP Community wohl bekannt. Er ist Koautor von PHP de Luxe (php-de-luxe.de) - dem momentan aktuellsten deutschen PHP-Buch für fortgeschrittene PHP-Programmierung.

Links

• [1] Socket-Funktionen von PHP: de.php.net/sockets
• [2] UNIX Socket FAQ: www.developerweb.net/sock-faq/
• [3] RFC zu HTTP 1.0: www.ietf.org/rfc/rfc1945.txt
• [4] RFC zu HTTP 1.1: www.ietf.org/rfc/rfc2616.txt
• [5] Multifunktionaler Webserver basierend auf PHPs Socket-Erweiterungen: nanoweb.si.kz/
• [6] Ein weiterer Webserver in PHP: daniel.lorch.cc/projects/phpserv/