SELFHTML/Aides à la navigation CGI/Perl Modules Perl| SELFHTML/Aides à la navigation CGI/Perl Modules Perl |
Le module CGI fait partie des 
modules standard depuis la version Perl 5.004. Il dispose d'une quantité de fonctions qui prennent en charge les tâches routinières typiques des scripts CGI. Les fonctions qu'il contient ont fait leurs preuves par leur utilisation répétée dans la pratique. C'est pourquoi il est judicieux de faire appel aux ressources proposées dans ce module pour les scripts CGI. Un inconvénient du module CGI est, il est vrai, qu'il est volumineux. Pour les scripts CGI qui sont appelés très souvent (par exemple les scripts de compteur d'accès aux pages fréquemment visitées), cela peut se faire sentir à la mobilisation des ressources de l'ordinateur serveur. Dans ces cas là une décision en connaissance de cause de ne pas employer le module CGI est tout à fait concevable. Pour la plupart des scripts CGI cependant, l'utilisation du module CGI est recommandée. Car le module prend aussi en charge entre autres toute une série d'adaptations automatiques à l'environnement d'exécution du script, par lesquelles des erreurs possibles sont évitées.
Le module CGI et constitué d'un module principal et de différents sous modules. Les sous modules exécutent des tâches spéciales comme par exemple le soutien du nouveau standard Fast-CGI ou le soutien de ce qu'on appelle les poussées du serveur (Server-Pushs).
Il y a deux façons d'utiliser le module CGI: la première orientées sur l'objet et la deuxième orientée sur la fonction. L'utilisation orientée sur l'objet passe pour plus élégante et offre davantage de possibilités comme par exemple la définition de plusieurs objets CGI indépendants dans le même script. C'est la raison pour laquelle les descriptions de cette section se limitent à l'utilisation orientée sur l'objet.
 
|
L'exemple qui suit montre comment incorporer le module CGI dans son propre script et l'utiliser dans un style orienté sur l'objet.
#!/usr/bin/perl -w
use CGI;
use CGI::Carp qw(fatalsToBrowser);
$cgi = new CGI;
print $cgi->header('text/plain'), "Hello monde";
|
Avec use CGI vous incorporez le module CGI dans votre script. Dans l'exemple est néanmoins encore incorporé un sous module nommé CGI::Carp, plus exactement une certaine fonction de ce sous-module, à savoir la fonction fatalsToBrowser. Il est toujours judicieux de l'incorporer lors du développement de scripts CGI. La fonction fait en sorte que tous les messages d'erreurs créés par l'interpréteur Perl soient sortis directement dans le navigateur.
Après avoir incorporé le module CGI, une nouvelle instance de l'objet CGI est créée avec $cgi = new CGI. Avec cette instruction, vous posez l'embranchement pour utiliser le module CGI de la façon orientée sur l'objet. L'instance objet de la classe CGI peut être maintenant adressée par la scalaire $cgi. Par la scalaire vous avez accès lors du reste de l'exécution du script aux fonctions proposées par le module CGI. Dans le contexte orienté sur l'objet on ne parle cependant plus de fonctions mais de méthodes.
Le nom de la scalaire, qui, dans l'exemple, s'appelle $cgi, peut être choisi librement. Étant donné cependant que vous aurez besoin très souvent la plupart du temps de la scalaire dans le reste du script, le choix d'un nom court est recommandé. Beaucoup de programmeurs travaillent avec des noms d'une seule lettre comme par exemple $q.
L'exemple ci-dessus envoie un simple "Hello monde" au navigateur qui appelle. Comme toujours lorsqu'un script CGI envoie quelque chose au navigateur appelant, il doit d'abord créer un entête HTTP. Le module CGI dispose pour le faire d'une fonction ou plutôt méthode nommée header(). Quand aucun argument n'est transmis à cette méthode, elle crée un entête HTTP pour le type Mime text/html, à savoir pour la sortie de code HTML. Dans l'exemple ci-dessus, du texte non formaté doit toutefois être envoyé. C'est la raison pour laquelle le type Mime text/plain est transmis à la fonction.
Au vu de l'exemple de l'appel de header() vous pouvez vous rendre compte comment fonctionne l'accès à la scalaire définie auparavant. Selon le schéma $Scalaire->méthode vous "pointez" sur la méthode, et cela avec la scalaire qui est liée à une instance déterminée de l'objet CGI créée au préalable.
Pour l'envoi de l'entête HTTP et du texte "Hello monde" à sortir la fonction Perl habituelle print est utilisée dans l'exemple. Cette fonction peut sortir simultanément plusieurs arguments séparés par des virgules. Dans l'exemple elle sort d'abord la valeur renvoyée par la méthode header(), à savoir l'entête HTTP désiré et ensuite le texte Hello monde.
|
|
Le module CGI dispose de ses propres méthodes pour envoyer du code HTML au navigateur.
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
my $auteur = "Marco Polo";
$cgi->default_dtd('-//W3C//DTD HTML 4.01 Transitional//EN');
print $cgi->header(),
$cgi->start_html('Carnet de voyage au Cap Ferret'),
$cgi->h1('Carnet de voyage au Cap Ferret'),
$cgi->p('La plus grande dune de sable en Europe a 117m de haut et
peut être vue par temps clair quand on se trouve sur le bord du bassin
d'Arcachon. Cap Ferret lui-même est un petit coin de campagne qui est
avant tout constitué de maisons de vacances. L'ostréiculture, la pêche
et le sport nautique imprègnent l'atmosphère du bassin d'Arcachon.'),
$cgi->hr({-noshade => undef, -size => '1'}),
$cgi->p({-style => 'color:red'}, "auteur: ", $cgi->i($auteur)),
$cgi->end_html();
|
Tout d'abord le module CGI est incorporé comme d'habitude avec use CGI. Pour l'utiliser dans un style orienté sur l'objet, une nouvelle instance de l'objet CGI est créée avec $cgi = new CGI. L'exemple ne fait rien d'autre que d'envoyer un petit fichier HTML complet au navigateur. D'abord l'entête HTTP pour HTML est créé avec $cgi->header(). Puis suit le code HTML.
Le code HTML n'est cependant pas noté comme d'habitude, mais par l'appel de méthodes que le module CGI met à disposition. Pour tous les éléments HTML courants et repères HTML, ce genre de méthodes existe. Ici vous pouvez soit créer l'élément HTML complet, soit uniquement le repère d'ouverture ou de fermeture. L'instruction $cgi->h1('Carnet de voyage au Cap Ferret') crée par exemple un élément HTML complet avec son contenu. Le code créé donne <h1>Carnet de voyage au Cap Ferret</h1>. Cela fonctionne de la même manière avec les autres éléments HTML. $cgi->b('texte important') créerait par exemple le code HTML <b>texte important</b>.
Avec la méthode default_dtd vous pouvez fixer l'indicateur DTD pour pouvoir structurer le document sorti conformément au standard.
Le titre de l'exemple pourrait aussi être noté de la façon suivante:
$cgi->start_h1(),"Carnet de voyage au Cap Ferret",$cgi->end_h1().
Outre la méthode de notation complète de l'élément, il y a aussi des méthodes pour ne créer qu'un repère HTML d'ouverture ou un repère HTML de fermeture. $cgi->start_h1() ne crée donc que le code HTML <h1>, et $cgi->end_h1() le code </h1>. Les méthodes correspondantes existent pour tous les éléments, donc par exemple également $cgi->start_b() et $cgi->end_b().
L'utilisation de méthodes pour les repères d'ouverture et de fermeture est indiquées quand ceux-ci sont éloignés l'un de l'autre et ont beaucoup de contenu. Ce qui est naturellement le cas avant tout pour <html>...</html> car l'élément inclut le fichier HTML complet. La méthode $cgi->start_html(), qui est aussi utilisée dans l'exemple a cependant une place particulière. Elle ne crée pas seulement un repère d'ouverture <html> mais elle écrit aussi l'entête standard du fichier HTML avec les éléments head et title. L'argument qui lui est transmis est écrit par la méthode comme contenu de l'élément title.
De nombreux repères HTML d'ouverture ont des attributs. Pour distinguer ceux-ci du contenu de l'élément, ces méthodes proposent une syntaxe particulière. Cela se reconnaît dans l'exemple ci-dessus à la ligne de séparation. Avec l'instruction: $cgi->hr({-noshade => undef, -size => '1'}) le code HTML <hr noshade size="1"> est créé. L'argument qui est transmis à la méthode doit pour cela figurer entre des parenthèses accolades { ou }. Chaque attribut est introduit par un signe moins -. Les affectations de valeur aux attributs sont séparées de l'attribut par l'opérateur =>. Plusieurs attributs sont comme dans l'exemple de hr séparés par des virgules à l'intérieur des parenthèses accolades.
Les méthodes pour la création d'éléments HTML peuvent aussi se voir transmettre plusieurs arguments. Pour le faire, vous devez séparer les arguments par des virgules. Vous en voyez un exemple plus complexe dans la dernière instruction $cgi->p(...). Cet appel de la méthode transmet trois arguments. Le premier argument est un attribut pour le repère d'ouverture <p>, à savoir un attribut style, dans lequel la couleur rouge de la police est définie. Le deuxième élément est un texte statique et le troisième argument montre deux autres possibilités: il contient un autre appel pour une méthode élément, à savoir $cgi->i() pour du texte en italique. Et l'argument transmis à cette méthode n'est pas un texte statique mais une scalaire nommée $auteur, qui est définie plus haut dans l'exemple.
Les arguments permettent donc l'imbrication commode d'éléments HTML, tout comme l'insertion de contenus variables qui ont été recherchés au préalable par le script.
L'incorporation du module CGI ne vous impose en aucun cas de créer du code HTML de cette façon. Vous pouvez aussi générer directement les sorties HTML avec la fonction print ou sortir des modèles lus auparavant. Vous pouvez aussi panacher les appels de méthodes du module CGI avec de la création commune de code HTML. Il n'y a donc aucun problème à noter des formes panachées comme celle-ci:
print "<hr noshade size='1'>",
$cgi->p({-style => 'color:red'}, "auteur: <i>$auteur</i>");
En principe, tous les noms d'éléments HTML à l'intérieurs de méthodes sont écrits en minuscules, donc par exemple start_div(), end_div() ou bien div(). Il existe toutefois quelques exceptions pour éviter des heurts avec des parties constituantes de Perl du même nom. Les éléments HTML Tr, Select, Link et Sub commencent par une majuscule donc par exemple dans une instruction comme:
$cgi->Sub('texte en indice').
Vous pouvez poser des commentaires HTML avec la méthode comment(). Ainsi l'instruction:
$cgi->comment('pas d'actualité pour l'instant')
crée le code HTML:
<!--pas d'actualité pour l'instant-->.
|
|
Les entêtes HTTP peuvent nécessiter parfois des informations supplémentaires. Et en ce qui concerne l'entête HTML, celui-ci peut de la même façon contenir des mentions générales importantes sur le fichier HTML, par exemple des repères Meta ou des attributs sur la mise en page dans le repère d'ouverture <body>.
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
$cgi->default_dtd('-//W3C//DTD HTML 4.01 Transitional//EN');
print $cgi->header(-type =>'text/html',
-expires =>'+1h'),
$cgi->start_html(-title =>'Page de test avec un lien',
-author =>'selfhtml@fr.selfhtml.org',
-base =>'true',
-target =>'_blank',
-meta =>{'keywords' =>'selfhtml, test',
'description'=>'un petit test avec un lien'},
-style =>{'src'=>'/styles/formate.css'},
-BGCOLOR=>'#FFFFCC',
-TEXT =>'#000000',
-LINK =>'red',
-VLINK =>'blue',
-ALINK =>'black'),
$cgi->p('un petit test avec ',
$cgi->a({-href => 'http://actuel.fr.selfhtml.org/'},'Lien à fr.selfhtml.org')),
$cgi->end_html();
|
Le script incorpore le module CGI avec use CGI et crée une nouvelle instance de l'objet CGI avec $cgi = new CGI. Pour la sortie HTML, qu'il crée ensuite, il utilise différentes possibilités pour influer sur l'entête HTTP et sur les données de l'entête de fichier HTML.
Vous pouvez transmettre plusieurs arguments aussi bien à la méthode header() pour la création de l'entête HTTP qu'à la méthode start_html() pour la création de l'entête HTML. Les deux méthodes connaissent chacune un argument standard: pour header() il s'agit du type Mime, et pour start_html() le contenu de l'élément title. C'est pourquoi vous pouvez mentionner ces arguments sans précaution particulière, donc par exemple sous la forme header('text/plain') ou bien start_html('Texte du titre'). Pour la mention de plusieurs autres arguments, vous devez cependant utiliser la syntaxe montrée ci-dessus. Ici chaque argument est constitué d'un nom de paramètre, introduit par un signe moins -, d'un opérateur flèche => et de la valeur souhaitée. Les deux tableaux suivants dressent la liste des arguments possibles.
Le tableau suivant fait la liste des mentions que vous pouvez noter pour l'entête HTTP. Les exemples de code dans la colonne de gauche représentent seulement le simple appel de la méthode header().
|
Le tableau suivant dresse la liste des mentions que vous pouvez noter pour l'entête de fichier HTML. . Les exemples de code dans la colonne de gauche représentent seulement le simple appel de la méthode start_html().
|
|
|
Beaucoup de scripts CGI sont appelés par des formulaires HTML. Une des tâches les plus importantes du module CGI est de ce fait de lire les données du formulaires transmises au script et de les tenir à disposition sous une forme pratique. L'exemple suivant est le même que celui de la partie Exemple pour l'échange alterné entre HTML et CGI, en utilisant cette fois cependant le module CGI.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>Page de commentaire</title> </head> <body bgcolor="#E0E0E0" text="#000000"> <h1>Votre commentaire</h1> <form action="/cgi-bin/comments.pl" method="post"> <p>Name:<br><input size="40" maxlength="40" name="utilisateur"></p> <p>Text:<br><textarea rows="5" cols="50" name="commentaire"></textarea></p> <p><input type="submit" value="envoyer"></p> </form> </body> </html> |
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
my @noms_champ = $cgi->param();
print $cgi->header(),
$cgi->start_html('avis CGI du programme '),
$cgi->h1('avis CGI du programme ',$cgi->i('comments.pl'));
foreach my $champ (@noms_champ) {
print $cgi->b('nom de champ: '),
$champ,
$cgi->b(', contenu: '),
$cgi->param($champ), "<br>";
}
print $cgi->end_html();
|
Le fichier HTML contient un formulaire qui appelle le script CGI comments.pl dans le repère d'ouverture <form> avec l'attribut action. La méthode de transmission choisie dans l'exemple est post. L'autre méthode, à savoir get, serait tout aussi possible. Le module CGI reconnaît automatiquement la méthode de transmission.
Le script CGI comments.pl lit simplement les données transmises et les renvoie formatées en HTML au navigateur appelant. Pour ce faire, le script incorpore d'abord le module CGI avec use CGI et crée une nouvelle instance de l'objet CGI avec $cgi = new CGI. Ensuite, l'accès aux méthodes de l'objet CGI est possible par la scalaire $cgi. La méthode param() est décisive pour le traitement du formulaire. Grâce à elle, le script peut aller chercher les données transmises.
Pour la méthode param tout dépend dans quel contexte elle est appelée. La valeur qu'elle renvoie en dépend. Dans l'exemple ci-dessus, c'est l'instruction @noms_champ = $cgi->param(). Il s'agit ici d'un contexte de liste, c'est à dire que la valeur renvoyée attendue est une liste. Avec ce genre d'appels, param() renvoie la totalité des noms de champs d'un formulaire lu. Il s'agit des noms ayant été fixés dans le formulaire HTML lors de la définition des champs de formulaire avec l'attribut name=. La recherche de tous les noms de champs dans une liste est pratique dans la mesure où ces noms peuvent être transmis par la suite comme paramètres à la méthode param(). Dans la sortie HTML du script, un tel appel de param() est contenu. Là est notée l'instruction $cgi->param($champ). Quand un nom de champ est transmis comme paramètre à param(), La méthode renvoie la valeur correspondante ou le contenu du champ. Le contexte est ensuite scalaire. Dans l'exemple ci-dessus, tous les noms de champs sont parcourus dans l'ordre dans la boucle foreach $champ (@noms_champ). Avec $cgi->param($champ) il peut alors être accédé au contenu respectivement actuel de chacun des champs du formulaire.
Le tableau suivant récapitules les possibilités d'appel de param().
|
|
|
Un script CGI a fréquemment besoin d'informations sur son environnement, par exemple sur le serveur, le navigateur appelant ou sur son propre emplacement de sauvegarde sur le serveur. Le module CGI dispose de différentes méthodes pour la recherche de ces données. Nombre d'entre elles ne donnent que des détails extraits des variables prédéfinies %ENV.
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
$cgi->default_dtd('-//W3C//DTD HTML 4.01 Transitional//EN');
print $cgi->header(),
$cgi->start_html('donnees_environnement'),
$cgi->start_table({-border => '1'}),
$cgi->Tr($cgi->th({-align => 'right'},'URI du script:'),
$cgi->td($cgi->url(-full => 1))),
$cgi->Tr($cgi->th({-align => 'right'},'URI relative du Script:'),
$cgi->td($cgi->url(-relative => 1))),
$cgi->Tr($cgi->th({-align => 'right'},'logiciel du serveur:'),
$cgi->td($cgi->server_software())),
$cgi->Tr($cgi->th({-align => 'right'},'logiciel du navigateur:'),
$cgi->td($cgi->user_agent())),
$cgi->end_table(),
$cgi->end_html();
|
Le script en exemple incorpore d'abord le module CGI avec use CGI et crée une nouvelle instance de l'objet CGI avec $cgi = new CGI. Ensuite, il envoie du code HTML au navigateur, à savoir un tableau avec quelques informations sur l'environnement. Les sorties HTML sont réalisées à l'aide des méthodes du module CGI et de leurs règles. Le tableau sorti dresse la liste dans la colonne de gauche dans un élément th, de l'information que chaque ligne respective que le tableau contient et dans la colonne de droite dans un élément td de la valeur correspondante. Cette valeur est recherchée à chaque fois avec une méthode du module CGI. Ainsi par exemple l'URI du script est-elle recherchée avec $cgi->url(-full => 1).
Le tableau suivant dresse la liste des méthodes disponibles pour les données d'environnement. Les exemples d'appels supposent qu'une instance de l'objet CGI a été créée avec $cgi = new CGI . Le tableau est trié par ordre alphabétique des noms de méthodes.
|
|
|
Les témoins de connexion sont des petites unités d'informations qu'une page Web peut sauvegarder sur le navigateur appelant. La sauvegarde et la gestion sont ici assurées par le navigateur de l'utilisateur. Les témoins de connexion permettent de sauvegarder des informations propres à l'utilisateur, comme l'heure et la date de sa dernière visite, ou des offres qu'il a cliquées pour les relire lors du prochain appel. Le module CGI soutient la pose et la lecture de ces témoins de connexion.
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
my $CTIME_String = localtime(time);
my $vieux_temoin = $cgi->cookie(-name=>'derniere_visite');
my $nouveau_temoin = $cgi->cookie(-name=>'derniere_visite',
-value=>$CTIME_String,
-expires=>'+3M',
-path=>'/');
print $cgi->header(-cookie=>$nouveau_temoin),
$cgi->start_html("Cookie-Test"),
$cgi->p("<b>La date de votre dernière visite sur cette page remonte à</b>: ", $vieux_temoin || 'inconnu'),
$cgi->p("<b>La nouvelle date de visite enregistrée est maintenant</b>: ", $CTIME_String),
$cgi->end_html();
|
Le script en exemple utilise un témoin de connexion à l'aide duquel il recherche la date et l'heure du dernier appel de la page et sauvegarde la date et l'heure actuelle comme nouveau dernier appel. Pour le contrôle, il génère une sortie HTML, dans laquelle le visiteur apprend quelle est l'ancienne date d'appel et quelle est celle qui vient d'être sauvegardée. Pour ce faire le script incorpore dans un premier temps le module CGI avec use CGI et crée une nouvelle instance de l'objet CGI avec $cgi = new CGI. Avec localtime(time) il recherche la date et l'heure actuelle et les sauvegarde dans la scalaire $CTIME_String. La lecture du témoin de connexion sont dirigées par la méthode cookie() du module CGI. Par la scalaire $cgi qui est liée à j'objet CGI créé, le script accède à la méthode avec $cgi->cookie().
La méthode cookie() attend des arguments. Selon les arguments qui lui sont transmis, elle lit un témoin de connexion existant ou en définit un nouveau. Tous les arguments se composent d'un nom d'argument et d'une valeur. Le nom d'argument commence par un signe moins -. Derrière le nom d'argument suit l'opérateur => suivi lui-même de la mention de la valeur souhaitée.
Pour la lecture, il suffit de mentionner l'argument -name. Si un témoin de connexion de ce nom existe, alors l'appel de cookie() renvoie sa valeur. C'est exactement ce qui se passe dans le premier appel de l'exemple ci-dessus. La valeur renvoyée est sauvegardée dans la scalaire $vieux_temoin. Dans l'exemple, le témoin de connexion a pour nom derniere_visite.
Pour la pose d'un témoin de connexion il vous faut transmettre au moins deux arguments à cookie(), à savoir les arguments -name et -value. Pour -value mentionnez la valeur devant être sauvegardée. Dans l'exemple ci-dessus, il s'agit du contenu de la scalaire calculée précédemment $CTIME_String. La seule mention de -value ne suffit pas à poser le témoin de connexion. Cela ne devient effectif qu'en envoyant l'entête HTTP au navigateur appelant. Pour le faire, la valeur renvoyée de l'appel de cookie() est tout d'abord sauvegardée et ce dans la scalaire $nouveau_temoin. Cette scalaire est ensuite envoyée comme valeur dans l'argument -cookie que vous envoyez ensuite au navigateur avec la méthode header() comme c'est indiqué dans l'exemple ci-dessus.
Un autre argument important de la méthode cookie() est -expires. Il vous permet de mentionner combien de temps le navigateur doit sauvegarder le témoin de connexion chez l'utilisateur. Quand vous ne mentionnez pas -expires, le navigateur ne conserve le témoin de connexion que jusqu'à ce que l'utilisateur ferme le navigateur. La période souhaitée pour la sauvegarde est à mentionner sous forme de chiffre précédé du signe plus et suivi d'une lettre pour indiquer l'unité de temps. La mention '+3M' de l'exemple signifie "3 mois". Les autres unités de temps sont s (secondes), m (minutes), h (heures), d (jours) et y (année). En plus de cela, les mentions de temps absolues au format UTC sont permises comme par exemple Friday, 08-Jun-2001 11:29:00 GMT+0100.
La méthode cookie() connaît en outre encore d'autres arguments. Avec -path vous mentionnez le chemin HTTP sur le serveur pour lequel ainsi que pour ses répertoires, le témoin de connexion doit s'appliquer. Si la mention manque, le témoin de connexion s'applique à tout le domaine à partir de le racine des documents. Avec -domain vous pouvez mentionner à quel sous-domaine, dans le domaine principal, le témoin de connexion doit s'appliquer (par exemple -domain => nouvelles.surceserveur.fr). Avec -secure, qui attend comme affectation de valeur true, donc par exemple 1 , vous obtenez que le témoin de connexion ne soit posé que si l'environnement serveur est un environnement sécurisé SSL. C'est important quand vous transmettez des données sensibles dans le témoin de protection, par exemple le numéro de carte de crédit de l'utilisateur pour le lui proposer lors de sa prochaine visite comme occupation par défaut d'un champ de formulaire.
|
|
Certains scripts servent à diriger l'utilisateur appelant sur une autre adresse et à régler auparavant éventuellement quelques tâches.
#!/usr/bin/perl -w
use strict;
use CGI;
my $cgi = new CGI;
use CGI::Carp qw(fatalsToBrowser);
open(FH,">>/usr/web/data/userlog.xml");
print FH "<user-call>\n <remote-host>",
$cgi->remote_host(),
"</remote-host>\n <user-agent>",
$cgi->user_agent(),
"</user-agent>\n <goto-url>",
$cgi->url_param('goto'),
"</goto-url>\n <time-stamp>",
localtime(time),
"</time-stamp>\n</user-call>\n";
close(FH);
print $cgi->redirect($cgi->url_param('goto'));
|
Le script en exemple attend à son appel un paramètre nommé goto dans l'URI auquel doit être affectée une adresse valide. Supposons que le script ait l'adresse "http://localhost/cgi-bin/redirect.pl", alors un appel concevable serait http://localhost/cgi-bin/redirect.pl?goto=http%3A%2F%2Factuel.fr.selfhtml.org/. Un tel appel pourrait par exemple figurer comme attribut href dans un lien qui mène l'utilisateur vraiment à actuel.fr.selfhtml.org/ mais en réunissant auparavant quelques renseignements sur l'utilisateur.
Le script incorpore dans un premier temps le module CGI avec use CGI et crée une nouvelle instance de l'objet CGI avec $cgi = new CGI. Le ré-acheminement est ensuite possible comme il est montré dans la toute dernière instruction de l'exemple avec print $cgi->redirect(). L'adresse désirée sur laquelle la déviation doit se faire est transmise comme argument à la méthode redirect(). Dans l'exemple, ce n'est pas une adresse statique qui est transmise mais la valeur obtenue de la variable d'environnement url_param('goto'). La valeur transmise par goto à l'appel du script y est contenue. Le script ne fait donc rien d'autre du point de vue de l'utilisateur que d'appeler l'adresse transmise.
Auparavant, le script écrit cependant quelques données concernant l'utilisateur dans un fichier XML. Dans ce fichier sont écrites des données comme le nom d'hôte, l'adresse IP de l'utilisateur, le type de son navigateur, l'adresse de ré-acheminement et les date et heure actuelles, recherchées avec localtime(time). Pour ouvrir et fermer le fichier, le script utilise les fonctions Perl habituelles open et close. Les données sont écrites comme d'habitude avec print et la mention du descripteur de fichier (dans l'exemple FH).
|
|
Le module CGI propose deux possibilités de réglage importantes avec lesquelles vous pouvez augmenter la sécurité d'un script CGI contre une utilisation délictueuse. Vous devez noter les deux commandes au début du script après avoir incorporé néanmoins le module CGI avec use CGI.
|
|
| |
 |
Ordinateur et langage écrit
|
 |
Modules CPAN
|
| SELFHTML/Aides à la navigation CGI/Perl Modules Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org
