10. PHP-Server
Da PHP-Programme von einem Webserver ausgeführt werden können, wird ein solches Programm zu einem serverseitigen Programm, das mehrere Clients bedienen kann. Aus Sicht des Clients entspricht der Aufruf eines Webdienstes der Anforderung der URL dieses Dienstes. Der Client kann in jeder beliebigen Sprache geschrieben sein, einschließlich PHP. Im letzteren Fall verwenden wir die soeben besprochenen Netzwerkfunktionen. Wir müssen auch wissen, wie man mit einem Webdienst „kommuniziert“, d. h. das HTTP-Protokoll verstehen, das für die Kommunikation zwischen einem Webserver und seinen Clients verwendet wird. Dies ist der Zweck der folgenden Programme.
Der in Abschnitt 9.2 beschriebene Web-Client ermöglichte es uns, einen Teil des HTTP-Protokolls zu erkunden.
In ihrer einfachsten Form sehen Client-Server-Austausche wie folgt aus:
- Der Client öffnet eine Verbindung zu Port 80 auf dem Webserver
- er stellt eine Anfrage nach einem Dokument
- der Webserver sendet das angeforderte Dokument und schließt die Verbindung
- Der Client schließt daraufhin die Verbindung
Der Client kann verschiedene Formen annehmen: HTML-Text, ein Bild, ein Video usw. Es kann sich um ein bereits vorhandenes Dokument (statisches Dokument) oder um ein Dokument handeln, das von einem Skript dynamisch generiert wird (dynamisches Dokument). Im letzteren Fall sprechen wir von Webprogrammierung. Das Skript zur dynamischen Generierung von Dokumenten kann in verschiedenen Sprachen geschrieben sein: PHP, Python, Perl, Java, Ruby, C#, VB.NET usw.
Hier verwenden wir PHP, um Textdokumente dynamisch zu generieren.
 |
- In [1] baut der Client eine Verbindung zum Server auf, fordert ein PHP-Skript an und sendet möglicherweise Parameter an dieses Skript
- In [2] führt der Webserver das PHP-Skript mithilfe des PHP-Interpreters aus. Dieses Skript generiert ein Dokument, das an den Client gesendet wird [3]
- Der Server schließt die Verbindung. Der Client tut dasselbe.
Der Webserver kann mehrere Clients gleichzeitig bedienen. Beim Softwarepaket WampServer handelt es sich bei dem Webserver um einen Apache-Server, einen Open-Source-Server der Apache Foundation (http://www.apache.org/). In den folgenden Anwendungen muss WampServer gestartet werden. Dadurch werden drei Komponenten aktiviert: der Apache-Webserver, das Datenbankmanagementsystem MySQL und der PHP-Interpreter.
Die vom Webserver ausgeführten Skripte werden mit dem NetBeans-Tool geschrieben. Bisher haben wir PHP-Skripte geschrieben, die in einer Konsolenumgebung ausgeführt werden:
 |
Der Benutzer nutzt die Konsole, um die Ausführung eines PHP-Skripts anzufordern und die Ergebnisse zu erhalten.
In den folgenden Client-Server-Anwendungen
- wird das Client-Skript in einer Konsolenumgebung ausgeführt
- wird das Serverskript in einer Webumgebung ausgeführt
 |
Das PHP-Skript des Servers kann nicht an beliebiger Stelle im Dateisystem abgelegt werden. Der Grund dafür ist, dass der Webserver an den in der Konfiguration festgelegten Speicherorten nach den angeforderten statischen und dynamischen Dokumenten sucht. Die Standardkonfiguration von WampServer bewirkt, dass Dokumente im Ordner <WampServer>/www gesucht werden, wobei <WampServer> der Installationsordner von WampServer ist. Wenn also ein Web-Client ein Dokument D mit der URL [http://localhost/D] anfordert, liefert der Webserver das Dokument D, das sich unter dem Pfad [<WampServer>/www/D] befindet.
In den folgenden Beispielen werden wir die Server-Skripte im Ordner [www/web-examples] ablegen. Wenn ein Server-Skript den Namen S.php trägt, wird es über die URL [http://localhost/exemples-web/S.php] vom Webserver angefordert. Das Dokument [<WampServer>/www/web-examples/S.php] wird dann bereitgestellt.
 |
Um mit NetBeans ein serverseitiges Skript zu erstellen, gehen wir wie folgt vor:
 |
- In [1] erstellen wir ein neues Projekt
- In [2] wählen wir die Kategorie [PHP] und das Projekt [PHP-Anwendung] aus
 |
- In [3] benennen wir das Projekt
- In [4] wählen wir einen Ordner für das Projekt
- In [5] legen wir fest, dass das Skript von einem lokalen Webserver ausgeführt werden muss (die URL des Skripts hat die Form http://localhost/...). Der lokale Webserver ist der Apache-Webserver von WampServer.
- In [6] geben wir die URL des Projekts an. Hier legen wir fest, dass auf ein Skript namens S.php im Projekt über die URL [http://localhost/exemples-web/S.php] zugegriffen wird. Aufgrund der obigen Angaben bedeutet dies, dass der Pfad zum Skript S.php im Dateisystem [<WampServer>/www/web-examples/S.php] lautet. Dies wird in [7] festgelegt. Hier legen wir fest, dass jedes S.php-Skript im Projekt in die Verzeichnisstruktur des Apache-Webservers kopiert werden soll.
- in [8], das neue Projekt.
Schreiben wir ein Testskript:
 |
- In [1] erstellen wir ein erstes PHP-Skript im Projekt [web-examples]
- In [2] geben wir ihm einen Namen
- In [3] fügen wir nach der Erstellung den folgenden Inhalt ein
Als Nächstes muss WampServer laufen.
 |
- In [4] führen wir das Webskript [example1.php] aus. NetBeans startet daraufhin den Standardbrowser des Computers und weist ihn an, die URL [http://localhost/exemples-web/exemple1.php] anzuzeigen [5]
- In [6] zeigt der Browser an, was das Server-Skript an den Client gesendet hat.
Im weiteren Verlauf werden wir auf zwei Arten von Web-Clients stoßen:
- einen Browser, wie oben beschrieben. Wir haben festgestellt, dass der Webserver eine Antwort in folgender Form sendet: HTTP-Header, Leerzeile, Text. Der Browser zeigt nur den Text an.
- ein PHP-Skript, das die gesamte Antwort anzeigt: HTTP-Header, Leerzeile, Text.
Im weiteren Verlauf
- werden serverseitige Skripte wie [Beispiel1.php] oben geschrieben
- werden clientseitige Skripte wie die Konsolenskripte geschrieben, die wir bisher erstellt haben.
10.1. Client/Server-Anwendung für Datum und Uhrzeit
10.1.1. Der Server (web_01)
<?php
// time: number of milliseconds since 01/01/1970
// date-time display format
// d: 2-digit day
// m: 2-digit month
// y: 2-digit year
// H: hour 0.23
// i : minutes
// s: seconds
print date("d/m/y H:i:s",time());
Im Grunde zeigt das obige PHP-Skript die aktuelle Uhrzeit auf dem Bildschirm an. Bei der Ausführung durch einen Webserver wird jedoch Stream 1 – der normalerweise mit dem Bildschirm verbunden ist – auf die Verbindung umgeleitet, die den Server mit seinem Client verbindet. Daher sendet das obige Skript im Webkontext die aktuelle Uhrzeit als Text an den Client.
Führen wir dieses Skript in NetBeans aus:
 |
- In [1] führen wir das Skript aus. Daraufhin wird ein Webbrowser gestartet.
- In [2] die vom Webbrowser angeforderte URL
- In [3] der vom Server-Skript gesendete Text
Der Client-Browser nutzt das HTTP-Protokoll, um mit dem Webserver zu kommunizieren. Wir haben die Struktur dieses Protokolls bereits beschrieben.
Der Client sendet Textzeilen, die sich in drei Teile unterteilen lassen: HTTP-Header, eine Leerzeile und das Dokument. Das an den Webserver gesendete Dokument ist in der Regel leer oder besteht aus einer Reihe von Parametern in der Form parami=vali, wobei vali ein Wert ist, den der Benutzer in ein HTML-Formular eingegeben hat.
Die Antwort des Servers hat dieselbe Struktur: HTTP-Header, eine Leerzeile und ein Dokument, wobei es sich bei dem Dokument diesmal um das vom Client-Browser angeforderte Dokument handelt. Hat der Client Parameter gesendet, hängt das zurückgegebene Dokument in der Regel von diesen Parametern ab.
Mit dem Firefox-Browser können Sie die tatsächlichen Daten einsehen, die zwischen dem Client und dem Webserver ausgetauscht werden. Es gibt ein Firefox-Plugin namens Firebug, mit dem Sie diesen Datenaustausch verfolgen können. Firebug ist unter der URL [https://addons.mozilla.org/fr/firefox/addon/firebug/] verfügbar. Wenn Sie diese URL mit dem Firefox-Browser aufrufen, können Sie das Firebug-Plugin herunterladen. Im Folgenden gehen wir davon aus, dass das Firebug-Plugin heruntergeladen und installiert wurde. Es ist über eine Option im Firefox-Menü zugänglich:
 |
Ein Firebug-Fenster öffnet sich innerhalb des Firefox-Browserfensters. Dieses Fenster verfügt selbst über ein Menü:
 |
Um den Datenaustausch zwischen Client und Server während einer HTTP-Anfrage anzuzeigen, geben wir die URL [http://localhost/exemples-web/web_01.php] in den Firefox-Browser ein. Das Firebug-Fenster füllt sich daraufhin mit Informationen:
 |
Oben sehen Sie eine Zusammenfassung des Datenaustauschs zwischen Client und Server:
- [1]: Der Client hat die HTTP-Anfrage gesendet: GET /exemples-web/web_01.php HTTP/1.1, um das Dokument [web01.php] anzufordern
- [2]: Der Server sendete die Antwort: HTTP/1.1 200 OK, was bedeutet, dass er das angeforderte Dokument gefunden hat.
Mit Firebug können Sie den gesamten Datenaustausch anzeigen. „Erweitern“ Sie dazu einfach die URL:
 |
Oben sehen wir die HTTP-Header, die zwischen dem Client (Anfrage) und dem Server (Antwort) ausgetauscht wurden. Es ist möglich, den Quellcode des Datenaustauschs abzurufen, d. h. die tatsächlich ausgetauschten Textzeilen [1]. Wir erhalten dann den folgenden Quellcode:
 |
Um ein clientseitiges Skript für den Webserver zu schreiben, müssen wir lediglich das Verhalten des Browsers nachbilden. Nach dem Aufbau einer Verbindung zum Server könnte das clientseitige Skript die oben gezeigten 8 Zeilen der Anfrage senden. Tatsächlich ist nicht alles notwendig, und wir werden nur die folgenden drei Zeilen senden:
- Zeile 1: gibt das angeforderte Dokument und das verwendete HTTP-Protokoll an
- Zeile 2: gibt den Hostnamen des Client-Skripts an
- Zeile 3: gibt an, dass der Client nach dem Austausch die Verbindung zum Server schließen wird
Sehen wir uns nun die Antwort des Servers an. Wir wissen, dass sie vom PHP-Skript [web_01.php] generiert wurde. Oben sehen wir die HTTP-Header der Antwort. Der Code des Skripts [web01.php] zeigt, dass es diese nicht generiert hat. Erinnern wir uns an die Konfiguration des Serverskripts:
 |
Es ist der Webserver, der die HTTP-Header der Antwort generiert hat. Das Server-Skript kann diese selbst generieren. Ein Beispiel dafür sehen wir uns etwas später an.
Wir haben erwähnt, dass die Antwort des Webservers folgende Form hat: HTTP-Header, Leerzeile, Dokument. Wenn es sich bei dem Dokument um ein Textdokument handelt, können wir es auf der Registerkarte [Response] von Firebug anzeigen:
 |
Diese Antwort wurde vom Skript [web_01.php] generiert.
10.1.2. Ein Client (client1_web_01)
Wir werden nun ein Client-Skript für den vorherigen Dienst schreiben. Wir wissen, dass der Client:
- eine Verbindung zum Webserver herstellen
- den Text senden: HTTP-Header, Leerzeile
- die vollständige Antwort des Servers lesen, bis der Server die Verbindung zum Client schließt
- die Verbindung zum Server schließen
Das Client-Skript wird in einer NetBeans-Konsolenumgebung ausgeführt:
 |
- In [1] ist das Client-Skript [client1_web_01.php] im NetBeans-Projekt [examples] enthalten
- in [2] die Eigenschaften des NetBeans-Projekts [examples]
- in [3] läuft das NetBeans-Projekt [examples] im „Befehlszeilen“-Modus, den wir auch als „Konsolen“-Modus bezeichnet haben.
Der Code des Client-Skripts lautet wie folgt:
<?php
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// open a connection on port 80 of $HOTE
$connexion = fsockopen($HOTE, $PORT);
// mistake?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// blank line
fputs($connexion,"\n");
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client therefore reads everything that arrives from $connexion
// until the channel closes
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
}//while
// the customer in turn closes the connection
fclose($connexion);
// end
exit;
Kommentare
- Zeile 8: Öffnen einer Verbindung zum Server
- Zeile 16: HTTP-GET-Befehl
- Zeile 18: HTTP-Host-Befehl
- Zeile 20: HTTP-Befehl „Connection“
- Zeile 22: Leerzeile
- Zeilen 26–28: Lesen aller vom Server gesendeten Textzeilen, bis dieser die Verbindung schließt.
- Zeile 30: Der Client schließt die Verbindung
Die Ausführung des Client-Skripts führt zu folgenden Ergebnissen:
Kommentare
- Zeilen 1–7: die HTTP-Antwort vom Webserver.
- Zeile 8: die Leerzeile, die das Ende der HTTP-Header signalisiert
- Zeilen 9 und folgende: das Dokument. Hier handelt es sich um einen einfachen Text, der das aktuelle Datum und die aktuelle Uhrzeit angibt. Dies ist der Text, der vom PHP-Skript geschrieben wurde, um Ausgabe Nr. 1 zu erzeugen.
- Zeile 1: Der Server antwortet, dass er das angeforderte Dokument gefunden hat.
- Zeile 2: Das aktuelle Datum und die aktuelle Uhrzeit des Servers
- Zeile 3: Identität des Webservers
- Zeile 4: Gibt an, dass das folgende Dokument von einem PHP-Skript generiert wurde
- Zeile 5: Anzahl der Zeichen im Dokument
- Zeile 6: Der Server gibt an, dass er nach dem Senden des Dokuments die Verbindung schließen wird
- Zeile 7: gibt an, dass das vom Server gesendete Dokument Text im HTML-Format ist. Dies ist hier falsch. Das Dokument ist reiner Text. Wenn das Dokument nicht im HTML-Format vorliegt, ist es Aufgabe des PHP-Skripts, dies anzugeben. Das haben wir hier nicht getan.
10.1.3. Ein zweiter Client (client2_web_01)
Der vorherige Client hat alles angezeigt, was der Webserver ihm gesendet hat. In der Praxis ignorieren wir in der Regel die HTTP-Header in der Antwort und konzentrieren uns auf den Hauptteil des Dokuments. Hier möchten wir das Datum und die Uhrzeit abrufen, die vom serverseitigen PHP-Skript gesendet wurden. Wir werden diese Informationen mithilfe eines regulären Ausdrucks abrufen.
<?php
// retrieve information sent by a web server
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// open a connection on port 80 of $HOTE
$connexion = fsockopen($HOTE, $PORT);
// mistake?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// blank line
fputs($connexion,"\n");
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client therefore reads everything that arrives from $connexion
// until it finds the line it's looking for in the form dd/mm/yy hh:mm:ss
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
if (preg_match("/(\d\d)\/(\d\d)\/(\d\d) (\d\d):(\d\d):(\d\d)/", $ligne, $champs)) {
// we retrieve the # fields
array_shift($champs); // e// removes the 1st element from the array fields
// we retrieve the 6 fields in 6 variables
list($j, $m, $a, $h, $i, $s) = $champs;
// result display
print "\ndateheure=[$j,$m,$a,$h,$i,$s]\n";
}////if
}//while
// the customer in turn closes the connection
fclose($connexion);
// end
exit;
10.2. Abruf der vom Client gesendeten Parameter durch den Server
Im HTTP-Protokoll stehen einem Client zwei Methoden zur Verfügung, um Parameter an den Webserver zu übergeben:
- Er fordert die Service-URL in der Form
GET url?param1=val1¶m2=val2¶m3=val3… HTTP/1.0
wobei die gültigen Werte zunächst kodiert werden müssen, sodass bestimmte reservierte Zeichen durch ihre Hexadezimalwerte ersetzt werden.
- Es fordert die Service-URL in der Form
POST url HTTP/1.0
und fügt dann unter den an den Server gesendeten HTTP-Headern den folgenden Header ein:
Die übrigen vom Client gesendeten Header enden mit einer Leerzeile. Anschließend kann er seine Daten in der Form
, wobei die gültigen Werte, wie bei der GET-Methode, zuvor kodiert werden müssen. Die Anzahl der an den Server gesendeten Zeichen muss N betragen, wobei N der im Header deklarierte Wert ist
Das PHP-Skript, das die vom Client gesendeten Parameter abruft, entnimmt deren Werte aus dem Array:
- $_GET["parami"] für eine GET-Anfrage
- $_POST["parami"] für eine POST-Anfrage
10.2.1. Der GET-Client (client1_web_02)
Das folgende PHP-Skript sendet drei Parameter [last_name, first_name, age] an den Server.
<?php
// client: sends firstname,lastname,age to the server using the GET method
// data
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_02.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// web server connection
$connexion = fsockopen($HOTE, $PORT);
// return if error
if (!$connexion) {
print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
exit;
}//if
// information sent to server PHP
// information is encoded
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
// console monitoring
print "infos envoyées au serveur (GET)=$infos\n";
print "URL demandée=[$URL?$infos]\n\n";
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $URL?$infos HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// blank line
fputs($connexion,"\n");
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client reads everything from $connexion until the channel is closed
while ($ligne = fgets($connexion, 1000))
print "$ligne";
// the customer in turn closes the connection
fclose($connexion);
Kommentare
- Zeile 7: URL des Server-Skripts
- Zeile 8: Werte der 3 Parameter
- Zeile 10: öffnet eine Verbindung zum Webserver
- Zeile 18: Kodierung der drei Parameter. Wir arbeiten in einem in NetBeans geschriebenen Skript mit UTF-8-Zeichenkodierung. Daher sind die drei Parameterwerte aus Zeile 8 in UTF-8 kodiert. Die Funktion `utf8_decode` wandelt ihre Kodierung in ISO-8859-1 um. Sobald dies geschehen ist, können sie für die URL kodiert werden. Alle nicht-alphabetischen Zeichen werden durch %xx ersetzt, wobei xx der Hexadezimalwert des Zeichens ist. Leerzeichen werden durch das Pluszeichen (+) ersetzt.
- Zeile 24: Die angeforderte URL lautet $URL?$infos, wobei $infos die Form last_name=val1&first_name=val2&age=val3 hat.
10.2.2. Der Server (web_02)
Der Server zeigt einfach an, was er empfängt.
<?php
// error management
ini_set("display_errors", "off");
// server retrieves information sent by the client
// here firstname=P&lastname=N&age=A
// this information is automatically available in the
// $_GET['prenom'], $_GET['nom'], $_GET['age']
// we send them back to the customer
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// parameters sent to server
$prenom = isset($_GET['prenom']) ? $_GET['prenom'] : "";
$nom = isset($_GET['nom']) ? $_GET['nom'] : "";
$age = isset($_GET['age']) ? $_GET['age'] : "";
// customer response
$réponse = "informations reçues du client [" .
utf8_encode(htmlspecialchars($prenom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($nom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($age, ENT_QUOTES)) . "]\n";
print $réponse;
Kommentare
- Zeile 13: Legt den HTTP-Header „Content-Type“ fest. Standardmäßig sendet der Webserver den Header
, was angibt, dass die Antwort Text im HTML-Format ist. Hier handelt es sich bei der Antwort um unformatierten Text mit Zeichen, die in UTF-8 kodiert sind:
HTTP-Header müssen vor der Antwort des Servers gesendet werden. Daher muss im obigen Code der Aufruf der Header-Funktion vor allen print-Anweisungen stehen.
- Zeilen 16–18: Wir lesen die drei Parameter aus dem Array $_GET aus.
- Zeile 21: Wir erstellen die Zeichenkette, die als Antwort an den Client gesendet wird. Bestimmte Zeichen haben in HTML eine besondere Bedeutung und müssen durch HTML-Entitäten ersetzt werden, um angezeigt zu werden. htmlspecialchars($string) ersetzt alle diese Zeichen durch ihre Entsprechungen in der Zeichenkette $string. Das Zeichen $ wird beispielsweise zu &. Da wir in Zeile 13 festgelegt haben, dass die Antwort als UTF-8-Text gesendet wird, kodieren wir die abgerufenen Werte in UTF-8.
- Zeile 25: Die Antwort wird an den Client gesendet
Führen wir das Skript [web_02] aus NetBeans aus. Daraufhin öffnet sich ein Browser, der die URL [http://localhost/exemples-web/web_02.php] anzeigt:
 |
- In [1] zeigt der Browser die URL [http://localhost/exemples-web/web_02.php] an. Da wir dieser URL keine Parameter angehängt haben, hat der Server mit leeren Parametern geantwortet. Erinnern Sie sich daran, dass die Antwort des Servers diejenige ist, die mit der print-Anweisung geschrieben wurde.
- In [2] fügen wir der URL Parameter hinzu. Diesmal gibt das Server-Skript diese korrekt zurück.
Beachten Sie, dass NetBeans nicht erforderlich ist, um ein Serverskript auszuführen. Geben Sie einfach die URL des Serverskripts in einen Browser ein, um es auszuführen.
Test 2
Wir führen den Client [client1_web_02.php] in NetBeans aus. Wir erhalten die folgende Antwort:
- Zeile 1: Kodierung der 3 Parameter. Wir sehen, dass das Zeichen û zu %FB geworden ist.
- Zeile 12: Die Antwort des Servers
10.2.3. Der POST-Client (client2_web_03)
Ein HTTP-Client sendet die folgende Textsequenz an den Webserver: HTTP-Header, Leerzeile, Dokument. Beim vorherigen Client sah diese Sequenz wie folgt aus:
Es gab kein Dokument. Es gibt eine weitere Möglichkeit, Parameter zu übermitteln, die als POST-Methode bekannt ist. In diesem Fall lautet die an den Webserver gesendete Textsequenz wie folgt:
Diesmal sind die Parameter, die im GET-Client in den HTTP-Headern enthalten waren, Teil des Dokuments, das im POST-Client nach den Headern gesendet wird.
Das Skript für den POST-Client lautet wie folgt:
<?php
// client: sends firstname,lastname,age to the server using the POST method
// data
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_03.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// web server connection
$connexion = fsockopen($HOTE, $PORT);
// return if error
if (!$connexion) {
print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
exit;
}//if
// information sent to server PHP
// information is encoded
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
print "client : infos envoyées au serveur (POST) : $infos\n";
// connect to the URL $URL by posting (POST) parameters to it
// protocol HTTP headers must end with an empty line
// POST
fputs($connexion, "POST $URL HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// Content-type
fputs($connexion, "Content-type: application/x-www-form-urlencoded\n");
// Content-length
// send the size (number of characters) of the information to be sent
fputs($connexion, "Content-length: " . strlen($infos) . "\n");
// send an empty line
fputs($connexion, "\n");
// we send the news
fputs($connexion, $infos);
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client reads everything that arrives from $connexion
// until the channel closes
while ($ligne = fgets($connexion, 1000))
print "$ligne";
// the customer in turn closes the connection
fclose($connexion);
Kommentare
- Zeile 7: Die URL des Webdienstes, mit dem sich der POST-Client verbinden wird. Dieser Webdienst wird in Kürze beschrieben.
- Zeile 8: Die an den Webdienst zu sendenden Parameter
- Zeile 10: Verbindung zum Webserver
- Zeile 18: Kodierung der an den Webdienst zu sendenden Parameter
- Zeile 23: HTTP-POST-Befehl
- Zeile 25: HTTP-Host-Befehl
- Zeile 27: HTTP-Connection-Header
- Zeile 29: HTTP-Content-Type-Header. Diesen HTTP-Header haben wir bereits kennengelernt. Er ist immer dann vorhanden, wenn ein Dokument gesendet wird. Ein Webserver, der ein HTML-Dokument sendet, verwendet den HTTP
Wenn er unformatierten Text sendet, verwendet er den HTTP-Header
Unser POST-Client sendet ein Dokument, das aus Text in der Form „param1=val1¶m2=val2&...“ besteht. Diese Art von Dokument hat den Typ „application/x-www-form-urlencoded“. Wir werden nicht näher darauf eingehen, warum das so ist, da wir dafür erklären müssten, was ein Webformular ist.
- Zeile 32: Content-Length-Anweisung. Wir sind diesem HTTP-Header bereits begegnet. Er ist jedes Mal vorhanden, wenn ein Dokument gesendet wird. Er gibt die Anzahl der Bytes im Dokument an.
- Zeile 34: Die Leerzeile, die das Ende der HTTP-Header anzeigt
- Zeile 36: Senden der Parameter
- Zeilen 40–41: Lesen der vollständigen Antwort vom Server
- Zeile 43: Schließen der Verbindung
10.2.4. Der Server (web_03)
Der Webdienst [web_03] führt dieselbe Aufgabe aus wie der Webdienst [web_02]. Er liest die vom POST-Client gesendeten Parameter und sendet sie an den Client zurück. Sein Code lautet wie folgt:
<?php
// error management
ini_set("display_errors", "off");
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// server retrieves information sent by the client
// here firstname=P&lastname=N&age=A
// this information is automatically available in the
// $_POST['prenom'], $_POST['nom'], $_POST['age']
// we send them back to the customer
// parameters sent to server
$prenom = isset($_POST['prenom']) ? $_POST['prenom'] : "";
$nom = isset($_POST['nom']) ? $_POST['nom'] : "";
$age = isset($_POST['age']) ? $_POST['age'] : "";
// customer response
$réponse = "informations reçues du client [" .
utf8_encode(htmlspecialchars($prenom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($nom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($age, ENT_QUOTES)) . "]\n";
print $réponse;
Kommentare
- Zeilen 14–16: Die von einem POST-Client gesendeten Parameter stehen dem Webdienst, der sie empfängt, im Array $_POST zur Verfügung.
- Zeile 6: HTTP-Header „Content-Type“. Es mag Sie überraschen, dass der HTTP-Header „Content-Length“, der die Größe des an den Client zurückgesendeten Dokuments angibt, in den HTTP-Headern fehlt. Wir haben gesehen, dass der Webserver standardmäßig HTTP-Header sendet. Der Header „Content-Length“ ist einer davon.
Sobald das Serverskript in NetBeans geschrieben ist, ist es sofort über den WampServer Apache-Server verfügbar. Beachten Sie, dass dies durch die Konfiguration erreicht wird (siehe Absatz 10). Wir starten den Client, der den Server abfragt, und erhalten dann die folgende Antwort:
- Zeilen 2–10: Antwort des Servers
- Zeilen 2–8: die HTTP-Header
- Zeile 10: das Dokument
- Zeile 6: der HTTP-Header „Content-Length“. Da dieser Header nicht vom Server-Skript generiert wurde, stammt er vom Webserver.
- Zeile 8: der einzige vom Server-Skript generierte Header
10.3. Abrufen von Webserver-Umgebungsvariablen
Ein Server-Skript läuft in einer Webumgebung, auf die es zugreifen kann. Diese Umgebung ist im $_SERVER-Dictionary gespeichert. Zunächst schreiben wir eine Serveranwendung, die den Inhalt dieses Dictionaries an ihre Clients sendet.
10.3.1. Der Server (web_04)
<?php
// error management
ini_set("display_errors", "off");
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// returns to the client the list of variables available in the server environment
foreach ($_SERVER as $clé => $valeur) {
print "[$clé,$valeur]\n";
}
- Die (Schlüssel, Wert)-Paare aus dem $_SERVER-Wörterbuch werden an die Clients gesendet.
Das Ergebnis, wenn der Client ein Webbrowser ist, sieht wie folgt aus:
Hier ist die Bedeutung einiger der Variablen (für Windows. Unter Linux wären sie anders):
CMDE steht für den vom Client gesendeten HTTP-Header. Wir haben Zugriff auf alle diese Header. | |
Der Pfad zu den ausführbaren Dateien auf dem Rechner, auf dem das Server-Skript läuft | |
Der Pfad zum DOS-Befehlsinterpreter | |
die Dateiendungen ausführbarer Dateien | |
der Windows-Installationsordner | |
die Webserver-Signatur. Hier steht nichts. | |
der Typ des Webservers | |
Der Internetname des Webserver-Rechners | |
Der Listening-Port des Webservers | |
die IP-Adresse des Webserver-Rechners | |
die IP-Adresse des Clients. In diesem Fall befand sich der Client auf demselben Rechner wie der Server. | |
der Kommunikationsport des Clients | |
das Stammverzeichnis der vom Webserver bereitgestellten Dokumente | |
die E-Mail-Adresse des Webserver-Administrators | |
der vollständige Pfad des Serverskripts | |
die vom Webserver verwendete Version des HTTP-Protokolls | |
die vom Client verwendete HTTP-Methode. Es gibt vier: GET, POST, PUT, DELETE | |
die mit einer GET-Anfrage gesendeten Parameter /url?parameters | |
Die vom Client angeforderte URL. Wenn der Browser die URL http://machine[:port]/uri anfordert, ist REQUEST_URI gleich uri | |
$_SERVER['SCRIPT_FILENAME'] = $_SERVER['DOCUMENT_ROOT'] . $_SERVER['SCRIPT_NAME'] |
10.3.2. Der Client (client1_web_04)
Der Client zeigt einfach alles an, was der Server ihm sendet.
<?php
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_04.php";
// open a connection on port 80 of $HOTE
$connexion = fsockopen($HOTE, $PORT);
// mistake?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// connect to the Web server on a URL
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// blank line
fputs($connexion,"\n");
// the server will now respond on channel $connexion. It will send all
// then close the channel. The client therefore reads everything that arrives from $connexion
// until the channel closes
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
}//while
// the customer in turn closes the connection
fclose($connexion);
// end
exit;
10.4. Web-Sitzungsverwaltung
In den vorherigen Client/Server-Beispielen verlief der Prozess wie folgt:
- Der Client öffnet eine Verbindung zu Port 80 auf dem Webserver
- er sendet die Textsequenz: HTTP-Header, Leerzeile, [Dokument]
- als Antwort sendet der Server eine Sequenz desselben Typs
- der Server schließt die Verbindung zum Client
- der Client schließt die Verbindung zum Server
Wenn derselbe Client kurz darauf eine neue Anfrage an den Webserver stellt, wird eine neue Verbindung zwischen dem Client und dem Server hergestellt. Der Server kann nicht erkennen, ob der sich verbindende Client bereits zuvor da war oder ob es sich um eine erstmalige Anfrage handelt. Zwischen den Verbindungen „vergisst“ der Server seinen Client. Aus diesem Grund wird das HTTP-Protokoll als zustandsloses Protokoll bezeichnet. Für den Server ist es jedoch nützlich, sich an seine Clients zu erinnern. Wenn eine Anwendung beispielsweise sicher ist, sendet der Client dem Server einen Benutzernamen und ein Passwort, um sich zu authentifizieren. Würde der Server seinen Client zwischen den Verbindungen „vergessen“, müsste sich der Client bei jeder neuen Verbindung erneut authentifizieren, was nicht praktikabel ist.
Um einen Client zu verfolgen, geht der Server wie folgt vor: Wenn ein Client eine erste Anfrage stellt, fügt der Server seiner Antwort eine Kennung hinzu, die der Client dann bei jeder nachfolgenden Anfrage zurücksenden muss. Anhand dieser Kennung – die für jeden Client einzigartig ist – kann der Server den Client erkennen. Er kann dann für diesen Client einen Datensatz in Form einer Datei führen, die eindeutig mit der Kennung des Clients verknüpft ist.
Technisch gesehen funktioniert das so:
- In der Antwort an einen neuen Client fügt der Server den HTTP-Header „Set-Cookie: Key=Identifier“ ein. Dies geschieht nur bei der ersten Anfrage.
- Bei nachfolgenden Anfragen sendet der Client seine Kennung über den HTTP-Cookie-Header: Key=Identifier, damit der Server ihn erkennen kann.
Man könnte sich fragen, woher der Server weiß, dass es sich um einen neuen Client und nicht um einen wiederkehrenden handelt. Das verrät ihm das Vorhandensein des HTTP-Cookie-Headers in den HTTP-Headern des Clients. Bei einem neuen Client fehlt dieser Header.
Die Gesamtheit der Verbindungen eines bestimmten Clients wird als Sitzung bezeichnet.
10.4.1. Die Konfigurationsdatei
Damit die Sitzungsverwaltung unter PHP korrekt funktioniert, müssen Sie sicherstellen, dass sie richtig konfiguriert ist. Unter Windows lautet der Name der Konfigurationsdatei PHP.ini. Je nach Ausführungskontext (Konsole, Web) muss sich die Konfigurationsdatei [PHP.ini] in unterschiedlichen Verzeichnissen befinden. Um diese zu finden, verwenden Sie das folgende Skript:
Zeile 4: Die Funktion phpinfo() liefert Informationen über den PHP-Interpreter, der das Skript ausführt. Insbesondere gibt sie den Pfad zur verwendeten Konfigurationsdatei [PHP.ini] zurück.
In einer Konsolenumgebung erhalten Sie ein Ergebnis, das in etwa wie folgt aussieht:
Zeile 2: Die Hauptkonfigurationsdatei ist c:\windows\PHP.ini
Zeile 3: Eine sekundäre Konfigurationsdatei ist C:\DBServers\wamp21\bin\PHP\php5.3.5\PHP.ini. Sie ermöglicht es Ihnen, bestimmte Konfigurationsoptionen in der Hauptkonfigurationsdatei zu ändern.
In einer Webumgebung ergibt sich folgendes Ergebnis:
Die sekundäre Konfigurationsdatei ist hier nicht dieselbe wie in der Konsolenumgebung. Letztere werden wir nun untersuchen. In dieser Datei gibt es einen Abschnitt für Sitzungen:
- Zeile 1: Die Daten der Client-Sitzung werden in einer Datei gespeichert
- Zeile 3: Das Verzeichnis, in dem die Sitzungsdaten gespeichert werden. Wenn dieses Verzeichnis nicht existiert, wird kein Fehler gemeldet und die Sitzungsverwaltung funktioniert nicht.
- Zeilen 4–5: Geben an, dass die Sitzungs-ID über die HTTP-Header „Set-Cookie“ und „Cookie“ verwaltet wird
- Zeile 6: Der Set-Cookie-Header hat die Form Set-Cookie: PHPSESSID=session_id
- Zeile 7: Eine Client-Sitzung wird nicht automatisch gestartet. Das Server-Skript muss sie explizit mit der Funktion session_start() anfordern.
10.4.2. Server 1 (web_05)
Die Verwaltung der Sitzungs-ID ist für einen Webdienst transparent. Diese Kennung wird vom Webserver verwaltet. Ein Webdienst greift über die Funktion session_start() auf die Sitzung des Clients zu. Von diesem Zeitpunkt an kann der Webdienst über das Array $_SESSION auf die Sitzung des Clients zugreifen und darin schreiben. Der folgende Code veranschaulicht die Sitzungsverwaltung für drei Zähler.
<?php
// error management
ini_set("display_errors", "off");
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// log in
session_start();
// on met 3 variables en session
if (!isset($_SESSION['N1'])) {
$_SESSION['N1'] = 0;
}
if (!isset($_SESSION['N2'])) {
$_SESSION['N2'] = 10;
}
if (!isset($_SESSION['N3'])) {
$_SESSION['N3'] = 100;
}
// incrementing the 3 variables
$_SESSION['N1']++;
$_SESSION['N2']++;
$_SESSION['N3']++;
// sending information to the customer
print "N1=".$_SESSION['N1']."\n";
print "N2=".$_SESSION['N2']."\n";
print "N3=".$_SESSION['N3']."\n";
// end of session
session_close();
- Zeile 9: Beginn einer Client-Sitzung
- Zeilen 11–13: Das Array $_SESSION ist ein Schlüssel-Wert-Wörterbuch. Die in diesem Wörterbuch gespeicherten Daten bleiben über mehrere Anfragen desselben Clients hinweg erhalten. Es fungiert als Speicher des Clients auf dem Server.
- Zeilen 11–19: Wenn die drei Zähler N1, N2, N3 nicht in der Sitzung vorhanden sind, werden sie hinzugefügt.
- Zeilen 21–23: Sie werden um eins erhöht
- Zeilen 25–27: Ihre Werte werden an den Client gesendet
In der Client-Server-Beziehung hängt die Verwaltung der Client-Sitzung auf dem Server von beiden Parteien ab, dem Client und dem Server:
- Der Server ist dafür verantwortlich, dem Client bei dessen erster Anfrage eine Kennung zu senden
- der Client ist dafür verantwortlich, diese Kennung bei jeder neuen Anfrage zurückzusenden. Tut er dies nicht, geht der Server davon aus, dass es sich um einen neuen Client handelt, und generiert eine neue Kennung für eine neue Sitzung.
Ergebnisse
Wir verwenden einen Webbrowser als Client. Standardmäßig (bzw. je nach Konfiguration) sendet der Browser tatsächlich die Sitzungskennungen, die der Server ihm übermittelt, an den Server zurück. Bei jeder Anfrage erhält der Browser die drei vom Server gesendeten Zähler und sieht, wie sich deren Werte erhöhen.
 |
- In [1] zeigt die erste Anfrage an den Webdienst [web_05]
- In [2] zeigt die dritte Anfrage, dass die Zähler tatsächlich erhöht werden. Die Zählerwerte werden tatsächlich über mehrere Anfragen hinweg gespeichert.
Verwenden wir Firebug, um die zwischen Server und Client ausgetauschten HTTP-Header anzuzeigen. Wir schließen Firefox, um die aktuelle Sitzung mit dem Server zu beenden, öffnen ihn erneut und aktivieren Firebug. Wir rufen den Dienst [web_05] auf:
 |
Oben sehen wir die Sitzungs-ID, die der Server in seiner Antwort auf die erste Anfrage des Clients gesendet hat. Er verwendet den HTTP-Header „Set-Cookie“.
Erstellen wir eine neue Anfrage, indem wir die Seite im Webbrowser aktualisieren (F5):
 |
Hier fallen uns zwei Dinge auf:
- Der Webbrowser sendet die Sitzungs-ID mit dem HTTP-Cookie-Header zurück.
- In seiner Antwort enthält der Webdienst diese Kennung nicht mehr. Es liegt nun in der Verantwortung des Clients, sie mit jeder seiner Anfragen zu senden.
10.4.3. Client 1 (client1_web_05)
Wir werden nun ein clientseitiges Skript schreiben, das auf dem vorherigen serverseitigen Skript basiert. Bei der Sitzungsverwaltung muss es sich wie der Webbrowser verhalten:
- In der Antwort des Servers auf seine erste Anfrage muss es die Sitzungs-ID finden, die der Server ihm sendet. Es weiß, dass es diese im HTTP-Set-Cookie-Header findet.
- Bei jeder nachfolgenden Anfrage muss er die empfangene Kennung an den Server zurücksenden. Dies geschieht über den HTTP-Cookie-Header.
Der Client-Code lautet wie folgt:
<?php
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_05.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
list($erreur, $cookie, $N1, $N2, $N3) = connecte($HOTE, $PORT, $urlServeur, $cookie);
print "----------------------------\n";
print "client(erreur,cookie,N1,N2,N3)=[$erreur,$cookie,$N1,$N2,$N3]\n";
print "----------------------------\n";
}
// end
exit;
function connecte($HOTE, $PORT, $urlServeur, $cookie) {
// connects client to ($HOTE,$PORT,$urlServeur)
// sends the $cookie cookie if it is non-empty
// displays all lines received in response
// open a connection on port 80 of $HOTE
$connexion = fsockopen($HOTE, $PORT);
// mistake?
if (!$connexion)
return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
// connect to $urlserveur
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion, "Connection: close\n");
// send cookie if non-empty
if ($cookie) {
fputs($connexion, "Cookie: $cookie\n");
}////if
// send empty line
fputs($connexion, "\n");
// the web server response is displayed
// and take care to retrieve any cookies and Ni
$N = "";
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
// cookie - only on 1st response
if (!$cookie) {
if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
$cookie = $champs[1];
}
}
// n1 value
if (preg_match("/^N1=(.*?)\s*$/", $ligne, $champs))
$N1 = $champs[1];
// n2 value
if (preg_match("/^N2=(.*?)\s*$/", $ligne, $champs))
$N2 = $champs[1];
// n3 value
if (preg_match("/^N3=(.*?)\s*$/", $ligne, $champs))
$N3 = $champs[1];
}////while
// close the connection
fclose($connexion);
// return
return array("", $cookie, $N1, $N2, $N3);
}
Kommentare
- Zeilen 3–16: das Hauptprogramm
- Zeilen 18–67: die Verbindungsfunktion
- Zeilen 9–14: Der Client ruft den Server fünfmal auf und zeigt die aufeinanderfolgenden Werte der Zähler N1, N2 und N3 an. Wenn die Sitzung korrekt verwaltet wird, sollten diese Zähler bei jeder neuen Anfrage um 1 erhöht werden.
- Zeile 10: Die Funktion `connecte` verwendet die Parameter `$HOTE`, `$PORT` und `$urlServeur`, um den Client mit dem Webdienst zu verbinden. Der Parameter `$cookie` stellt die Sitzungs-ID dar. Beim ersten Aufruf ist dies eine leere Zeichenkette. Bei nachfolgenden Aufrufen ist es die Sitzungs-ID, die der Server als Antwort auf den ersten Aufruf des Clients gesendet hat. Die Funktion `connecte` gibt die Werte der drei Zähler `$N1`, `$N2`, `$N3`, die Sitzungs-ID `$cookie` und eventuelle Fehler in `$erreur` zurück.
- Zeile 18: Die Funktion `connecte` weist die Eigenschaften eines Standard-HTTP-Clients auf. Wir werden nur auf die neuen Funktionen eingehen.
- Zeilen 30–40: Senden von HTTP-Headern.
- Zeilen 36–38: Wenn die Sitzungs-ID bekannt ist, wird sie an den Server gesendet
- Zeilen 44–66: Verarbeitung aller vom Server gesendeten Textzeilen
- Zeilen 47–51: Wenn die Sitzungs-ID noch nicht abgerufen wurde, wird sie mithilfe eines regulären Ausdrucks aus dem HTTP-Header „Set-Cookie“ abgerufen.
- Zeilen 53–54: Der Zähler N1 wird ebenfalls mithilfe eines regulären Ausdrucks ermittelt
- Zeilen 56–57, 59–60: Gleiches gilt für die Zähler N2 und N3
- Zeile 63: Die Verbindung zum Server wird geschlossen.
- Zeile 65: Die Ergebnisse werden als Array zurückgegeben.
Durch Ausführen des Client-Skripts wird Folgendes in der NetBeans-Konsole angezeigt:
- Zeile 5: In seiner ersten Antwort sendet der Server die Sitzungs-ID. In nachfolgenden Antworten sendet er sie nicht mehr.
- Es ist offensichtlich, dass der Webserver die Werte von (N1, N2, N3) über die Anfragen des Clients hinweg beibehält. Dies wird als Sitzungsverfolgung bezeichnet.
Die folgenden beiden Beispiele zeigen, dass Sie auch die Werte eines Arrays oder eines Objekts speichern können.
10.4.4. Server 2 (web_06)
Das folgende Serverskript zeigt, dass ein Array oder ein Dictionary in einer Sitzung gespeichert werden kann.
<?php
// error management
ini_set("display_errors", "off");
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// log in
session_start();
// save a table and a dictionary
// initialize or modify the table
if (isset($_SESSION['tableau'])) {
for ($i = 0; $i < count($_SESSION['tableau']); $i++) {
$_SESSION['tableau'][$i]++;
}
} else {
for ($i = 0; $i < 10; $i++) {
$_SESSION['tableau'][$i] = $i * 10;
}
}
// initialize or modify the dictionary
if (isset($_SESSION['dico'])) {
foreach (array_keys($_SESSION['dico']) as $clé) {
$_SESSION['dico'][$clé]++;
}
} else {
$_SESSION['dico'] = array("zéro" => 0, "dix" => 10, "vingt" => 20);
}
// sending information to the customer
print "tableau=" . join(",", $_SESSION['tableau']) . "\n";
print "dico=";
foreach ($_SESSION['dico'] as $clé => $valeur) {
print "($clé,$valeur) ";
}
print "\n";
Kommentare
- Zeilen 17–19: Ein Array wird zunächst erstellt, falls es noch nicht existiert
- Zeilen 12–15: Wenn es bereits existiert, werden seine Elemente um 1 erhöht
- Zeile 27: Ein Wörterbuch mit numerischen Werten wird initialisiert, falls es noch nicht existiert
- Zeilen 22–25: Wenn es bereits in der Sitzung vorhanden ist, werden seine numerischen Werte um 1 erhöht
- Zeilen 30–35: Das Array und das Wörterbuch werden an den Client gesendet
10.4.5. Client 2 (client1_web_06)
<?php
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_06.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
connecte($HOTE, $PORT, $urlServeur, $cookie);
}
// end
exit;
function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
// connects client to ($HOTE,$PORT,$urlServeur)
// sends the $cookie cookie if it is non-empty
// displays all lines received in response
// the cookie is passed by reference to be shared between
// the called program and the calling program
// open a connection on the $PORT port of $HOTE
$connexion = fsockopen($HOTE, $PORT);
// mistake?
if (!$connexion)
return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
// protocol HTTP headers must end with an empty line
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion, "Connection: close\n");
// send cookie if non-empty
if ($cookie) {
fputs($connexion, "Cookie: $cookie\n");
}
// send empty line
fputs($connexion, "\n");
// the web server response is displayed
// and we take care to recover any cookie
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
// cookie - only on 1st response
if (!$cookie) {
if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
$cookie = $champs[1];
}
}
}
// close the connection
fclose($connexion);
// return
return "";
}
Der Client-Code ähnelt dem bereits auskommentierten Client-Code.
10.4.6. Server 3 (web_07)
Das folgende Server-Skript zeigt, dass ein Objekt in einer Sitzung gespeichert werden kann.
<?php
// error management
ini_set("display_errors", "off");
// uTF-8 header
header("Content-Type: text/plain; charset=utf-8");
// log in
session_start();
// initialize or modify a Personne object
if (isset($_SESSION['personne'])) {
$personne = $_SESSION['personne'];
// increment age
$personne->setAge($personne->getAge() + 1);
} else {
// we define the person
$_SESSION['personne'] = new Personne("paul", "langévin", 10);
}
// customer display
print "personne=".$_SESSION['personne']."\n";
// end
exit;
// ----------------------------------------------------------------
class Personne {
// class attributes
private $prénom;
private $nom;
private $âge;
// getters and setters
public function getPrénom() {
return $this->prénom;
}
public function getNom() {
return $this->nom;
}
public function getAge() {
return $this->âge;
}
public function setPrénom($prénom) {
$this->prénom = $prénom;
}
public function setNom($nom) {
$this->nom = $nom;
}
public function setAge($age) {
$this->âge = $age;
}
// manufacturer
function __construct($prénom, $nom, $âge) {
// we go through sets
$this->setPrénom($prénom);
$this->setNom($nom);
$this->setAge($âge);
}
// method toString
function __toString() {
return "[$this->prénom,$this->nom,$this->âge]";
}
}
Kommentare
- Zeile 17: Wir fügen der Sitzung ein Person-Objekt hinzu, falls es noch nicht vorhanden ist.
- Zeilen 11–15: Wenn es bereits vorhanden ist, erhöhen wir sein Alter um 1
- Zeile 20: Wir senden das „Person“-Objekt an den Client.
10.4.7. Client 3 (client1_web_07)
<?php
// data
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_07.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
connecte($HOTE, $PORT, $urlServeur, $cookie);
}//if
// end
exit;
function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
...
}
Kommentare
- Zeile 15: Die connect-Funktion ist identisch mit der im vorherigen Client-Skript