Introduction à PHP 5 par l'exemple

<?php
// time : nb de millisecondes depuis 01/01/1970
// format affichage date-heure
// d: jour sur 2 chiffres
// m: mois sur 2 chiffres
// y : année sur 2 chiffres
// H : heure 0,23
// i : minutes
// s: secondes
print date("d/m/y H:i:s",time());

Basiquement, le script PHP ci-dessus écrit l'heure courante sur l'écran. Cependant, lorsqu'il est exécuté par un serveur web, le flux n° 1 qui est habituellement associé à l'écran est redirigé vers la connexion qui lie le serveur à son client. Donc, dans un contexte web, le script ci-dessus envoie l'heure courante sous forme de texte au client.

Exécutons ce script au sein de Netbeans :

• en [1], on exécute le script. Un navigateur web est alors lancé.
• en [2], l'Url demandée par le navigateur web
• en [3], le texte envoyé par le script serveur

Le navigateur client utilise le protocole Http pour dialoguer avec le serveur web. Nous avons déjà décrit la forme de ce protocole.

Le client envoie des lignes de texte qu'on peut décomposer en trois parties : entêtes Http, ligne vide, document . Le document envoyé au serveur web est le plus souvent vide ou bien c'est un ensemble de paramètres parami=vali où vali est une valeur saisie par l'utilisateur dans un formulaire Html.

La réponse du serveur a la même forme : entêtes Http, ligne vide, document où document est cette fois le document demandé par le navigateur client. Si le client a transmis des paramètres, le document délivré dépend en général de ces paramètres.

Avec le navigateur Firefox , il est possible de découvrir les échanges réels entre client et serveur web. Il existe un plugin pour Firefox , appelé Firebug qui permet de tracer ces échanges. Firebug est disponible à l'Url [https://addons.mozilla.org/fr/firefox/addon/firebug/]. Si on utilise le navigateur Firefox pour visiter cette Url, on peut alors télécharger le plugin Firebug . Nous supposons dans la suite que le plugin Firebug a été téléchargé et installé. Il est disponible via une option du menu de Firefox  :

Une fenêtre Firebug s'ouvre dans la fenêtre du navigateur Firefox. Cette fenêtre présente elle-même un menu :

Pour découvrir les échanges client / serveur lors d'une requête Http, nous demandons l'Url [http://localhost/exemples-web/web_01.php] avec le navigateur Firefox. La fenêtre de Firebug se remplit alors d'informations :

Ci-dessus, on a un résumé des échanges client / serveur :

• [1] : le client a envoyé la commande HTTP : GET /exemples-web/web_01.php HTTP/1.1 pour demander le document [web01.php]
• [2] : le serveur a envoyé la réponse : HTTP/1.1 200 OK indiquant qu'il a trouvé le document demandé.

Firebug permet d'obtenir les échanges complets. Il suffit de "déplier" l'Url :

Nous voyons ci-dessus les en-têtes Http échangés entre le client (Requête) et le serveur (Réponse). Il est possible d'avoir le code source des échanges, c.a.d. les lignes de texte réellement échangées [1]. Nous obtenons alors le code source suivant :

Pour écrire un script client du serveur web, il nous suffit de reproduire le comportement du navigateur. Après avoir ouvert une connexion avec le serveur, le script client pourrait envoyer les 8 lignes de la requête ci-dessus. En fait tout n'est pas indispensable et nous n'enverrons que les trois lignes suivantes :

GET /exemples-web/web01.php HTTP/1.1
Host: localhost
Connection: close

• ligne 1 : précise le document demandé et le protocole Http utilisé
• ligne 2 : donne le nom de la machine du script client
• ligne 3 : indique qu'après l'échange, le client fermera la connexion au serveur

Intéressons-nous maintenant à la réponse du serveur. Nous savons qu'elle a été produite par le script PHP [web_01.php]. Ci-dessus, nous voyons les entêtes Http de la réponse. Le code du script [web01.php] montre que ce n'est pas lui qui les a générés. Rappelons-nous la configuration du script serveur :

C'est le serveur web qui a généré les entêtes Http de la réponse. Le script serveur peut les générer lui-même. Nous en verrons un exemple un peu plus loin.

Nous avons dit que la réponse du serveur web était de la forme : entêtes Http, ligne vide, document. Si le document est un document texte, on peut voir celui-ci dans l'onglet [Réponse] de Firebug :

Cette réponse a été générée par le script [web_01.php].

Nous écrivons maintenant un script client pour le service précédent. Nous savons que le client doit :

• ouvrir une connexion avec le serveur web
• envoyer le texte : entêtes Http, ligne vide
• lire la réponse complète du serveur jusqu'à ce que celui-ci ferme sa connexion avec le client
• fermer sla connexion avec le serveur

Le script client s'exécute dans un environnement console de Netbeans :

• en [1], le script client [client1_web_01.php] est inclus dans le projet Netbeans [exemples]
• en [2], les propriétés du projet Netbeans [exemples]
• en [3], le projet Netbeans [exemples] s'exécute en mode "ligne de commande", ce que nous avons appelé aussi le mode "console".

Le code du script client est le suivant :

<?php

// données
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// ouverture d'une connexion sur le port 80 de $HOTE
$connexion = fsockopen($HOTE, $PORT);
// erreur ?
if (!$connexion) {
  print "Erreur : $erreur\n";
  exit;
}
// les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// ligne vide
fputs($connexion,"\n");
// le serveur va maintenant répondre sur le canal $connexion. Il va envoyer toutes
// ses données puis fermer le canal. Le client lit donc tout ce qui arrive de $connexion
// jusqu'à la fermeture du canal
while ($ligne = fgets($connexion, 1000)) {
  print "$ligne";
}//while
// le client ferme la connexion à son tour
fclose($connexion);
// fin
exit;

Commentaires

• ligne 8 : ouverture d'une connexion vers le serveur
• ligne 16 : commande Http GET
• ligne 18 : commande Http Host
• ligne 20 : commande Http Connection
• ligne 22 : ligne vide
• lignes 26-28 : lecture de toutes les lignes de texte envoyées par le serveur jusqu'à ce qu'il ferme la connexion.
• ligne 30 : le client ferme à son tour la connexion

Résultats

L'exécution du script client produit les résultats suivants :

HTTP/1.1 200 OK
Date: Wed, 17 Aug 2011 13:35:00 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Content-Length: 17
Connection: close
Content-Type: text/html

17/08/11 13:35:00

Commentaires

• lignes 1-7 : la réponse Http du serveur web.
• ligne 8 : la ligne vide qui signale la fin des entêtes Http
• lignes 9 et au-delà : le document. Ici, c'est un simple texte représentant la date et l'heure courante. C'est le texte écrit par le script PHP sur la sortie n° 1.
• ligne 1 : le serveur répond qu'il a trouvé le document demandé.
• ligne 2 : date et heure courantes du serveur
• ligne 3 : identité du serveur web
• ligne 4 : indique que le document qui va suivre est un document généré par un script PHP
• ligne 5 : nombre de caractères du document
• ligne 6 : le serveur indique qu'après avoir envoyé le document, il va fermer la connexion
• ligne 7 : indique que le document envoyé par le serveur est un texte au format Html. C'est inexact ici. Le document est du texte sans format particulier. Lorsque le document n'est pas du texte au format Html, c'est au script PHP de l'indiquer. Nous ne l'avons pas fait ici.

Le client précédent affichait tout ce que lui envoyait le serveur web. Dans la pratique, on ignore généralement les entêtes Http de la réponse et on exploite la partie document. Nous cherchons ici à récupérer la date et l'heure envoyées par le script PHP serveur. Nous allons récupérer ces informations au moyen d'une expression régulière.

<?php

// récupérer les informations envoyées par un serveur web
// données
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// ouverture d'une connexion sur le port 80 de $HOTE
$connexion = fsockopen($HOTE, $PORT);
// erreur ?
if (!$connexion) {
  print "Erreur : $erreur\n";
  exit;
}
// les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// ligne vide
fputs($connexion,"\n");
// le serveur va maintenant répondre sur le canal $connexion. Il va envoyer toutes
// ces données puis fermer le canal. Le client lit donc tout ce qui arrive de $connexion
// jusqu'à trouver la ligne qu'il cherche de la forme jj/mm/aa 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)) {
    // on récupère les # champs
    array_shift($champs); // enlève le 1er élément du tableau champs
    // on récupère les 6 champs dans 6 variables
    list($j, $m, $a, $h, $i, $s) = $champs;
    // affichage résultat
    print "\ndateheure=[$j,$m,$a,$h,$i,$s]\n";
  }//if
}//while
// le client ferme la connexion à son tour
fclose($connexion);
// fin
exit;

Résultats

HTTP/1.1 200 OK
Date: Wed, 17 Aug 2011 14:14:51 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Content-Length: 17
Connection: close
Content-Type: text/html

17/08/11 14:14:51
dateheure=[17,08,11,14,14,51]

Le script PHP ci-dessous envoie trois paramètres [nom, prenom, age] au serveur.

<?php

// client : envoie prenom,nom,age au serveur par la méthode GET
// données
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_02.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// connexion au serveur web
$connexion = fsockopen($HOTE, $PORT);
// retour si erreur
if (!$connexion) {
  print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
  exit;
}//if
// envoi des informations au serveur php
// on encode les informations
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
// suivi console
print "infos envoyées au serveur (GET)=$infos\n";
print "URL demandée=[$URL?$infos]\n\n";
// les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
// GET
fputs($connexion, "GET $URL?$infos HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// ligne vide
fputs($connexion,"\n");
// le serveur va maintenant répondre sur le canal $connexion. Il va envoyer toutes
// ses données puis fermer le canal. Le client lit tout ce qui arrive de $connexion jusqu'à la fermeture du canal
while ($ligne = fgets($connexion, 1000))
  print "$ligne";
// le client ferme la connexion à son tour
fclose($connexion);

Commentaires

• ligne 7 : Url du script serveur
• ligne 8 : les valeurs des 3 paramètres
• ligne 10 : ouverture d'une connexion avec le serveur web
• ligne 18 : encodage des 3 paramètres. Nous sommes dans un script écrit sous Netbeans avec un encodage des caractères en UTF-8. Donc les 3 valeurs des paramètres de la ligne 8 sont encodés en UTF-8. La fonction utf8_decode passe leur encodage en ISO-8859-1. Ceci fait, ils peuvent être encodés pour l'Url. Tous les caractères non alphabétiques sont remplacés par %xx où xx est la valeur hexadécimale du caractère. Les espaces sont eux remplacés par le signe +.
• ligne 24 : l'Url demandée est $URL?$infos où $ infos est de la forme nom=val1&prenom=val2&age=val3 .

Le serveur se contente d'afficher ce qu'il reçoit.

<?php

// gestion des erreurs
ini_set("display_errors", "off");

// récupération par le serveur des informations envoyées par le client
// ici prenom=P&nom=N&age=A
// ces informations sont automatiquement disponibles dans les variables
// $_GET['prenom'], $_GET['nom'], $_GET['age']
// on les renvoie au client

// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// paramètres envoyés au serveur
$prenom = isset($_GET['prenom']) ? $_GET['prenom'] : "";
$nom = isset($_GET['nom']) ? $_GET['nom'] : "";
$age = isset($_GET['age']) ? $_GET['age'] : "";

// réponse au client
$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;

Commentaires

• ligne 13 : fixe l'entête Http "Content-Type". Par défaut, le serveur web envoie l'entête

Content-Type: text/html

qui dit que la réponse est du texte au format Html. Ici, la réponse sera du texte sans formatage avec des caractères encodés en UTF-8 :

Content-Type: text/plain; charset=utf-8

Les entêtes Http doivent être envoyés avant la réponse du serveur. Aussi ci-dessus, l'appel de la fonction header se trouvera-t-elle avant toute instruction print.

• lignes 16-18 : on récupère les 3 paramètres dans le tableau $_GET.
• ligne 21 : on construit la chaîne de caractères qui va être envoyée en réponse au client. Certains caractères ont des significations spéciales en HTML, et doivent être remplacés par des entités HTML pour être affichés. htmlspecialchars($string) remplace tous ces caractères par leur équivalent dans la chaîne $string. Par exemple, le caractère $ devient &amp. Ensuite comme nous avons dit en ligne 13 que la réponse serait du texte UTF-8, nous encodons en UTF-8 les valeurs récupérées.
• ligne 25 : la réponse est envoyée au client

Test 1

Exécutons le script [web_02] à partir de Netbeans. Un navigateur est alors lancé pour afficher l'Url [http://localhost/exemples-web/web_02.php] :

• en [1], la navigateur affiche l'Url [http://localhost/exemples-web/web_02.php]. Parce que nous n'avons pas suffixé cette Url avec des paramètres, le serveur a répondu avec des paramètres vides. Rappelons que la réponse du serveur est celle écrite avec l'instruction print.
• en [2], nous suffixons l'Url avec des paramètres. Cette fois-ci le script serveur les renvoie bien.

Notons que Netbeans n'est pas nécessaire à l'exécution d'un script serveur. Il suffit de taper l'Url du script serveur dans un navigateur pour que ce script soit exécuté.

Test 2

On exécute dans Netbeans le client [client1_web_02.php]. On reçoit la réponse suivante :

infos envoyées au serveur (GET)=prenom=jean-paul&nom=de+la+h%FBche&age=45
URL demandée=[/exemples-web/web_02.php?prenom=jean-paul&nom=de+la+h%FBche&age=45]

HTTP/1.1 200 OK
Date: Wed, 17 Aug 2011 14:31:01 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Content-Length: 59
Connection: close
Content-Type: text/plain; charset=utf-8

informations reçues du client [jean-paul,de la hûche,45]

• ligne 1 : encodage des 3 paramètres. On voit que le caractère û est devenu %FB.
• ligne 12 : la réponse du serveur

Un client Http envoie au serveur web la séquence de texte suivante : entêtes Http, ligne vide, document. Dans le client précédent, cette séquence était la suivante :

GET /url?paramètres HTTP/1.1
… autres entêtes Http
ligne vide

Il n'y avait pas de document. Il existe une autre façon de transmettre des paramètres, la méthode dite POST. Dans ce cas, la séquence de texte envoyée au serveur web est la suivante :

POST /url HTTP/1.1
… autres entêtes Http
ligne vide
paramètres

Cette fois-ci, les paramètres qui pour le client GET étaient inclus dans les entêtes Http, font partie, dans le client POST, du document envoyé derrière les entêtes.

Le script du client POST est le suivant :

<?php

// client : envoie prenom,nom,age au serveur par la méthode POST
// données
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_03.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// connexion au serveur web
$connexion = fsockopen($HOTE, $PORT);
// retour si erreur
if (!$connexion) {
  print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
  exit;
}//if
// envoi des informations au serveur php
// on encode les informations
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
print "client : infos envoyées au serveur (POST) : $infos\n";
// on se connecte à l'URL $URL en lui postant (POST) des paramètres
// les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
// 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
// on envoie la taille (nombre de caractères) des infos qui vont être envoyées
fputs($connexion, "Content-length: " . strlen($infos) . "\n");
// on envoie une ligne vide
fputs($connexion, "\n");
// on envoie les infos
fputs($connexion, $infos);
// le serveur va maintenant répondre sur le canal $connexion. Il va envoyer toutes
// ses données puis fermer le canal. Le client lit tout ce qui arrive de $connexion
// jusqu'à la fermeture du canal
while ($ligne = fgets($connexion, 1000))
  print "$ligne";
// le client ferme la connexion à son tour
fclose($connexion);

Commentaires

• ligne 7 : l'Url du service web auquel le client POST va se connecter. Ce service web va être prochainement décrit.
• ligne 8 : les paramètres à transmettre au service web
• ligne 10 : connexion au serveur web
• ligne 18 : encodage des paramètres à envoyer au service web
• ligne 23 : commande Http POST
• ligne 25 : commande Http Host
• ligne 27 : commande Http Connection
• ligne 29 : commande Http Content-type. Nous avons déjà rencontré cet entête Http. Il est présent à chaque fois qu'un document est envoyé. Un serveur web qui envoie un document Html, utilise l'entête Http

Content-type : text/html

S'il envoie du texte non formaté, il utilise l'entête Http

Content-type : text/plain

Notre client POST envoie un document qui est un texte de la forme param1=val1&param2=val2&…. Ce type de document a le type application/x-www-form-urlencoded. Nous n'expliquerons pas pourquoi car cela nous obligerait à expliquer ce qu'est un formulaire web.

• ligne 32 : commande Content-length. Nous avons déjà rencontré cet entête Http. Il est présent à chaque fois qu'un document est envoyé. Il indique le nombre d'octets du document.
• ligne 34 : la ligne vide signalant la fin des entêtes Http
• ligne 36 : l'envoi des paramètres
• lignes 40-41 : lecture de la réponse complète du serveur
• ligne 43 : fermeture de la connexion

Le service web [web_03] fait la même chose que le service web [web_02]. Il lit les paramètres envoyés par le client POST et les erenvoie au client. Son code est le suivant :

<?php

// gestion des erreurs
ini_set("display_errors", "off");
// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// récupération par le serveur des informations envoyées par le client
// ici prenom=P&nom=N&age=A
// ces informations sont automatiquement disponibles dans les variables
// $_POST['prenom'], $_POST['nom'], $_POST['age']
// on les renvoie au client
// paramètres envoyés au serveur
$prenom = isset($_POST['prenom']) ? $_POST['prenom'] : "";
$nom = isset($_POST['nom']) ? $_POST['nom'] : "";
$age = isset($_POST['age']) ? $_POST['age'] : "";
// réponse au client
$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;

Commentaires

• lignes 14-16 : les paramètres envoyés par un client POST deviennent disponibles dans le tableau $_POST pour le service web qui les reçoit.
• ligne 6 : entête Http Content-Type. On peut s'étonner de ne pas trouver dans les entêtes Http l'entête Http Content-Length indiquant la taille du document renvoyé au client. Nous avons vu que le serveur web envoyait des entêtes Http par défaut. L'entête Content-Length en fait partie.

Résultats

Une fois le script serveur écrit sous Netbreans, il devient immédiatement disponible via le serveur Apache de WampServer. Rappelons-nous que cela est obtenu par configuration (cf page ). On lance le client qui interroge le serveur et on reçoit alors la réponse suivante :

client : infos envoyées au serveur (POST) : prenom=jean-paul&nom=de+la+h%FBche&age=45
HTTP/1.1 200 OK
Date: Sat, 20 Aug 2011 12:55:19 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Content-Length: 59
Connection: close
Content-Type: text/plain; charset=utf-8

informations reçues du client [jean-paul,de la hûche,45]

• lignes 2-10 : la réponse du serveur
• lignes 2-8 : les en-têtes Http
• ligne 10 : le document
• ligne 6 : l'en-tête Http Content-Length. Comme ce n'est pas le script serveur qui a généré cet en-tête, il a donc été généré par le serveur web.
• ligne 8 : le seul en-tête généré par le script serveur

<?php

// gestion des erreurs
ini_set("display_errors", "off");
// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// on renvoie au client la liste des variables disponibles dans l'environnement du serveur
foreach ($_SERVER as $clé => $valeur) {
  print "[$clé,$valeur]\n";
}

• les couples (clé, valeur) du dictionnaire $_SERVER sont envoyés aux clients.

Le résultat obtenu lorsque le client est un navigateur web est le suivant :

Voici la signification de certaines des variables (pour windows. Sous Linux, elles seraient différentes) :

Le client se contente d'afficher tout ce que lui envoie le serveur.

<?php

// données
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_04.php";
// ouverture d'une connexion sur le port 80 de $HOTE
$connexion = fsockopen($HOTE, $PORT);
// erreur ?
if (!$connexion) {
  print "Erreur : $erreur\n";
  exit;
}

// on se connecte sur une URL au serveur Web
// les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Connection
fputs($connexion,"Connection: close\n");
// ligne vide
fputs($connexion,"\n");
// le serveur va maintenant répondre sur le canal $connexion. Il va envoyer toutes
// ses données puis fermer le canal. Le client lit donc tout ce qui arrive de $connexion
// jusqu'à la fermeture du canal
while ($ligne = fgets($connexion, 1000)) {
  print "$ligne";
}//while
// le client ferme la connexion à son tour
fclose($connexion);
// fin
exit;

Résultats

HTTP/1.1 200 OK
Date: Sat, 20 Aug 2011 14:11:58 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Content-Length: 1353
Connection: close
Content-Type: text/plain; charset=utf-8

[HTTP_HOST,localhost]
[HTTP_CONNECTION,close]
[PATH,C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\Microsoft SQL Server\90\Tools\binn\;...;]
[SystemRoot,C:\Windows]
[COMSPEC,C:\Windows\system32\cmd.exe]
[PATHEXT,.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC]
[WINDIR,C:\Windows]
[SERVER_SIGNATURE,]
[SERVER_SOFTWARE,Apache/2.2.17 (Win32) PHP/5.3.5]
[SERVER_NAME,localhost]
[SERVER_ADDR,127.0.0.1]
[SERVER_PORT,80]
[REMOTE_ADDR,127.0.0.1]
[DOCUMENT_ROOT,C:/serveursSGBD/wamp21/www/]
[SERVER_ADMIN,admin@localhost]
[SCRIPT_FILENAME,C:/serveursSGBD/wamp21/www/exemples-web/web_04.php]
[REMOTE_PORT,54552]
[GATEWAY_INTERFACE,CGI/1.1]
[SERVER_PROTOCOL,HTTP/1.1]
[REQUEST_METHOD,GET]
[QUERY_STRING,]
[REQUEST_URI,/exemples-web/web_04.php]
[SCRIPT_NAME,/exemples-web/web_04.php]
[PHP_SELF,/exemples-web/web_04.php]
[REQUEST_TIME,1313849518]

Pour que la gestion des sessions fonctionne correctement avec PHP, il faut vérifier que celui-ci est correctement configuré. Sous windows, son fichier de configuration est php.ini. Selon le contexte d'exécution (console, web), le fichier de configuration [php.ini] doit être recherché dans des dossiers différents. Pour découvrir ceux-ci, on utilisera le script suivant :

<?php

// infos PHP
phpinfo();

Ligne 4, la fonction phpinfo donne des informations sur l'interpréteur PHP qui exécute le script. Elle donne notamment le chemin du fichier de configuration [php.ini] utilisé.

Dans un environnement console, on obtient un résultat analogue au suivant :

…
Configuration File (php.ini) Path => C:\Windows
Loaded Configuration File => C:\serveursSGBD\wamp21\bin\php\PHP5.3.5\php.ini
Scan this dir for additional .ini files => (none)
Additional .ini files parsed => (none)
…

ligne 2 : le fichier de configuration principal est c:\windows\php.ini

ligne 3 : un fichier de configuration secondaire est C:\serveursSGBD\wamp21\bin\php\PHP5.3.5\php.ini. Il permet de modifier certaines options de configuration du fichier de configuration principal.

Dans un environnement web, on obtient le résultat suivant :

Le fichier secondaire de configuration n'est ici pas le même que dans l'environnement console. C'est ce dernier que nous allons consulter. On trouve dans ce fichier une section session :

[Session]
session.save_handler = files
session.save_path = "C:/serveursSGBD/wamp21/tmp"
session.use_cookies = 1
session.use_only_cookies = 1
session.name = PHPSESSID
session.auto_start = 0
session.cookie_lifetime = 0
session.cookie_path = /
session.cookie_domain =
session.serialize_handler = php
session.cache_expire = 180
session.hash_function = 0

• ligne 1 : les données d'une session client sont sauvegardées dans un fichier
• ligne 3 : le dossier de sauvegarde des données de session. Si ce dossier n'existe pas, aucune erreur n'est signalée et la gestion des sessions ne fonctionne pas.
• lignes 4-5 : indiquent que l'identifiant de session est géré par les en-têtes Http Set-Cookie et Cookie
• ligne 6 : l'entête Set-Cookie sera de la forme Set-Cookie : PHPSESSID=identifiant_de_session
• ligne 7 : une session client n'est pas démarrée automatiquement. Le script serveur doit la demander explicitement par une instruction session_start().

La gestion de l'identifiant de session est transparent pour un service web. Cet identifiant est géré par le serveur web. Un service web a accès à la session du client via l'instruction session_start(). A partir de ce moment, le service web peut lire / écrire des données dans la session du client via le dictionnaire $_SESSION. Le code suivant montre la gestion en session de trois compteurs.

<?php

// gestion des erreurs
ini_set("display_errors", "off");
// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// on ouvre une session
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;
}
// incrémentation des 3 variables
$_SESSION['N1']++;
$_SESSION['N2']++;
$_SESSION['N3']++;
// envoi d'informations au client
print "N1=".$_SESSION['N1']."\n";
print "N2=".$_SESSION['N2']."\n";
print "N3=".$_SESSION['N3']."\n";
// fin de session
session_close();

• ligne 9 : démarrage d'une session client
• lignes 11-13 : le tableau $_SESSION est un dictionnaire de couple (clé, valeur). Les données mises dans ce dictionnaire persistent au fil des requêtes d'un même client. C'est la mémoire du client sur le serveur.
• lignes 11-19 : si les trois compteurs N1, N2, N3 ne sont pas en session, on les y met.
• lignes 21-23 : on les incrémente d'une unité
• lignes 25-27 : on envoie leur valeur au client

Dans la relation client / serveur, la gestion de la session client sur le serveur dépend des deux acteurs, le client et le serveur :

• le serveur a la charge d'envoyer un identifiant à son client lors de sa première demande
• le client a la charge de renvoyer cet identifiant à chaque nouvelle demande. S'il ne le fait pas, le serveur croira que c'est un nouveau client et génèrera un nouvel identifiant pour une nouvelle session.

Résultats

Nous utilisons comme client, un navigateur web. Par défaut (par configuration en fait), celui-ci renvoie bien au serveur les identifiants de session que celui-ci lui envoie. Au fil des requêtes, le navigateur va recevoir les trois compteurs envoyés par le serveur et va voir leurs valeurs s'incrémenter.

• en [1], la 1re demande au service web [web_05]
• en [2], la 3ième demande montre que les compteurs sont bien incrémentés. Il y a bien mémorisation des valeurs des compteurs au fil des demandes.

Utilisons Firebug pour voir les en-têtes Http échangés entre le serveur et le client. Nous fermons Firefox pour terminer la session courante avec le serveur, le rouvrons et activons Firebug. Nous demandons le service |web_05] :

Ci-dessus, on voit l'identifiant de session envoyé par le serveur dans sa réponse à la 1re demande du client. Il utilise l'en-tête Http Set-Cookie.

Faisons une nouvelle demande en rafraîchissant (F5) la page dans le navigateur web :

Ci-dessus on remarquera deux choses :

• le navigateur web renvoie l'identifiant de session avec l'en-tête Http Cookie.
• dans sa réponse, le service web n'inclut plus cet identifiant. C'est désormais le client qui a la charge de l'envoyer à chacune de ses demandes.

Nous écrivons maintenant un script client du script serveur précédent. Dans sa gestion de la session, il doit se comporter comme le navigateur web :

• dans la réponse du serveur à sa première demande, il doit trouver l'identifiant de session que le serveur lui envoie. Il sait qu'il le trouvera dans l'en-tête Http Set-Cookie.
• il doit, à chacune de ses demandes ultérieures, renvoyer au serveur l'identifiant qu'il a reçu. Il le fera avec l'en-tête Http Cookie.

Le code du client est le suivant :

<?php

// données
$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";
}
// fin
exit;

function connecte($HOTE, $PORT, $urlServeur, $cookie) {
  // connecte le client à ($HOTE,$PORT,$urlServeur)
  // envoie le cookie $cookie si celui-ci est non vide
  // affiche ttes les lignes reçues en réponse
  // ouverture d'une connexion sur le port 80 de $HOTE
  $connexion = fsockopen($HOTE, $PORT);
  // erreur ?
  if (!$connexion)
    return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
  // on se connecte sur $urlserveur
  // les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
  // GET
  fputs($connexion, "GET $urlServeur HTTP/1.1\n");
  // Host
  fputs($connexion, "Host: localhost\n");
  // Connection
  fputs($connexion, "Connection: close\n");
  // on envoie le cookie s'il est non vide
  if ($cookie) {
    fputs($connexion, "Cookie: $cookie\n");
  }//if
  // envoi ligne vide
  fputs($connexion, "\n");
  // on affiche la réponse du serveur web
  // et on prend soin de récupérer l'éventuel cookie et les valeurs des Ni
  $N = "";
  while ($ligne = fgets($connexion, 1000)) {
    print "$ligne";
    // cookie - seulement lors de la 1ère réponse
    if (!$cookie) {
      if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
        $cookie = $champs[1];
      }
    }
    // valeur de N1
    if (preg_match("/^N1=(.*?)\s*$/", $ligne, $champs))
      $N1 = $champs[1];
    // valeur de N2
    if (preg_match("/^N2=(.*?)\s*$/", $ligne, $champs))
      $N2 = $champs[1];
    // valeur de N3
    if (preg_match("/^N3=(.*?)\s*$/", $ligne, $champs))
      $N3 = $champs[1];
  }//while
  // on ferme la connexion
  fclose($connexion);
  // retour
  return array("", $cookie, $N1, $N2, $N3);
}

Commentaires

• lignes 3-16 : le programme principal
• lignes 18-67 : la fonction connecte
• lignes 9-14 : le client appelle 5 fois le serveur et affiche les valeurs successives des compteurs N1, N2 et N3. Si la session est correctement gérée, ces compteurs devraient être incrémentés de 1 à chaque nouvelle demande.
• ligne 10 : la fonction connecte utilise les paramètres $HOTE, $PORT, $urlServeur pour connecter le client au service web. Le paramètre $cookie représente l'identifiant de session. Au 1er appel, c'est la chaîne vide. Aux suivants, c'est l'identifiant de session envoyé par le serveur en réponse au 1er appel du client. La fonction connecte renvoie en résultats, les valeurs des trois compteurs $N1, $N2, $N3, l'identifiant de session $cookie et une éventuelle erreur $erreur.
• ligne 18 : la fonction connecte a les caractéristiques d'un client Http classique. Nous ne commentons que les nouveautés.
• lignes 30-40 : envoi des en-têtes Http.
• lignes 36-38 : si l'identifiant de session est connu, on l'envoie au serveur
• lignes 44-66 : exploitation de toutes les lignes de texte envoyées par le serveur
• lignes 47-51 : si l'identifiant de session n'a pas encore été récupéré, on le récupère dans l'en-tête Http Set-Cookie par une expression régulière.
• lignes 53-54 : le compteur N1 est obtenu lui aussi par une expression régulière
• lignes 56-57, 59-60 : idem pour les compteurs N2 et N3
• ligne 63 : fermeture de la connexion avec le serveur.
• ligne 65 : renvoi des résultats sous la forme d'un tableau.

Résultats

L'exécution du script client provoque l'affichage suivant dans la console Netbeans :

HTTP/1.1 200 OK
Date: Sun, 21 Aug 2011 13:59:17 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Set-Cookie: PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Length: 18
Connection: close
Content-Type: text/plain; charset=utf-8

N1=1
N2=11
N3=101
----------------------------
client(erreur,cookie,N1,N2,N3)=[,PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/,1,11,101]
----------------------------
HTTP/1.1 200 OK
Date: Sun, 21 Aug 2011 13:59:18 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Length: 18
Connection: close
Content-Type: text/plain; charset=utf-8

N1=2
N2=12
N3=102
----------------------------
client(erreur,cookie,N1,N2,N3)=[,PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/,2,12,102]
----------------------------
HTTP/1.1 200 OK
Date: Sun, 21 Aug 2011 13:59:18 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Length: 18
Connection: close
Content-Type: text/plain; charset=utf-8

N1=3
N2=13
N3=103
----------------------------
client(erreur,cookie,N1,N2,N3)=[,PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/,3,13,103]
----------------------------
HTTP/1.1 200 OK
Date: Sun, 21 Aug 2011 13:59:18 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Length: 18
Connection: close
Content-Type: text/plain; charset=utf-8

N1=4
N2=14
N3=104
----------------------------
client(erreur,cookie,N1,N2,N3)=[,PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/,4,14,104]
----------------------------
HTTP/1.1 200 OK
Date: Sun, 21 Aug 2011 13:59:18 GMT
Server: Apache/2.2.17 (Win32) PHP/5.3.5
X-Powered-By: PHP/5.3.5
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Length: 18
Connection: close
Content-Type: text/plain; charset=utf-8

N1=5
N2=15
N3=105
----------------------------
client(erreur,cookie,N1,N2,N3)=[,PHPSESSID=ohiqtkv7hu2b26kdshjtqms9p7; path=/,5,15,105]

• ligne 5 : dans sa première réponse, le serveur envoie l'identifiant de session. Dans les réponses suivantes, il ne l'envoie plus.
• on voit clairement que le serveur Web conserve les valeurs de (N1,N2,N3) au fil des demandes du client. C'est ce qu'on appelle le suivi de session.

Les deux exemples qui suivent montrent qu'on peut aussi sauvegarder les valeurs d'un tableau ou d'un objet.

Le script serveur suivant montre qu'on peut mettre en session un tableau ou un dictionnaire.

<?php

// gestion des erreurs
ini_set("display_errors", "off");
// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// on ouvre une session
session_start();
// on enregistre un tableau et un dictionnaire
// on initialise ou modifie le tableau
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;
  }
}
// on initialise ou modifie le dictionnaire
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);
}
// envoi d'informations au client
print "tableau=" . join(",", $_SESSION['tableau']) . "\n";
print "dico=";
foreach ($_SESSION['dico'] as $clé => $valeur) {
  print "($clé,$valeur) ";
}
print "\n";

Commentaires

• lignes 17-19 : un tableau est initialement mis en session s'il n'y est pas déjà
• lignes 12-15 : s'il y est déjà, ses éléments sont incrémentés de 1
• ligne 27 : un dictionnaire à valeurs numériques est mis en session s'il n'y est pas déjà
• lignes 22-25 : s'il y est déjà, ses valeurs numériques sont incrémentées de 1
• lignes 30-35 : le tableau et le dictionnaire sont envoyés au client

<?php

// données
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_06.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
  connecte($HOTE, $PORT, $urlServeur, $cookie);
}
// fin
exit;

function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
  // connecte le client à ($HOTE,$PORT,$urlServeur)
  // envoie le cookie $cookie si celui-ci est non vide
  // affiche ttes les lignes reçues en réponse
  // le cookie est passé par référence pour être partagé entre
  // le programme appelé et le programme appelant
  // ouverture d'une connexion sur le port $PORT de $HOTE
  $connexion = fsockopen($HOTE, $PORT);
  // erreur ?
  if (!$connexion)
    return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
  // les entêtes (headers) du protocole HTTP doivent se terminer par une ligne vide
  // GET
  fputs($connexion, "GET $urlServeur HTTP/1.1\n");
  // Host
  fputs($connexion, "Host: localhost\n");
  // Connection
  fputs($connexion, "Connection: close\n");
  // on envoie le cookie s'il est non vide
  if ($cookie) {
    fputs($connexion, "Cookie: $cookie\n");
  }
  // envoi ligne vide
  fputs($connexion, "\n");
  // on affiche la réponse du serveur web
  // et on prend soin de récupérer l'éventuel cookie
  while ($ligne = fgets($connexion, 1000)) {
    print "$ligne";
    // cookie - seulement lors de la 1ère réponse
    if (!$cookie) {
      if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
        $cookie = $champs[1];
      }
    }
  }
  // on ferme la connexion
  fclose($connexion);
  // retour
  return "";
}

Le code du client est analogue au code du client déjà commenté.

Résultats

HTTP/1.1 200 OK
...
Set-Cookie: PHPSESSID=6lvttr0uhpj5q3sl91h4h7p322; path=/
...

tableau=0,10,20,30,40,50,60,70,80,90
dico=(zéro,0) (dix,10) (vingt,20) 

HTTP/1.1 200 OK
...

tableau=1,11,21,31,41,51,61,71,81,91
dico=(zéro,1) (dix,11) (vingt,21) 

HTTP/1.1 200 OK
...

tableau=2,12,22,32,42,52,62,72,82,92
dico=(zéro,2) (dix,12) (vingt,22) 

HTTP/1.1 200 OK
...

tableau=3,13,23,33,43,53,63,73,83,93
dico=(zéro,3) (dix,13) (vingt,23) 

HTTP/1.1 200 OK
...

tableau=4,14,24,34,44,54,64,74,84,94
dico=(zéro,4) (dix,14) (vingt,24)

Le script serveur suivant montre qu'on peut mettre en session un objet.

<?php

// gestion des erreurs
ini_set("display_errors", "off");
// entête UTF-8
header("Content-Type: text/plain; charset=utf-8");

// on ouvre une session
session_start();
// on initialise ou modifie un objet Personne
if (isset($_SESSION['personne'])) {
  $personne = $_SESSION['personne'];
  // on incrémente l'âge
  $personne->setAge($personne->getAge() + 1);
} else {
  // on définit la personne
  $_SESSION['personne'] = new Personne("paul", "langévin", 10);
}
// affichage au client
print "personne=".$_SESSION['personne']."\n";
// fin
exit;

// ----------------------------------------------------------------
class Personne {

// attributs de la classe
  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;
  }

// constructeur
  function __construct($prénom, $nom, $âge) {
    // on passe par les set
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

// méthode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }

}

Commentaires

• ligne 17 : on met en session un objet de type Personne s'il n'y est pas déjà.
• lignes 11-15 : s'il y est déjà, on incrémente son âge de 1
• ligne 20 : on envoie l'objet de type Personne au client.

<?php

// données
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_07.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
  connecte($HOTE, $PORT, $urlServeur, $cookie);
}//if
// fin
exit;

function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
...
}

Commentaires

• ligne 15 : la fonction connecte est identique à celle du script client précédent

Résultats

HTTP/1.1 200 OK
...

personne=[paul,langévin,10]

HTTP/1.1 200 OK
...

personne=[paul,langévin,11]

HTTP/1.1 200 OK
...

personne=[paul,langévin,12]

HTTP/1.1 200 OK
...

personne=[paul,langévin,13]

HTTP/1.1 200 OK
...

personne=[paul,langévin,14]