next up previous contents index
Next: Conclusion Up: Scripts CGI Previous: CGI, base   Contents   Index

Subsections

Remplacement de mots clefs

OpenScheme facilite la récupération des arguments CGI issus des formulaires et la conversion du texte en sortie au format HTML :

Récupération des arguments

La fonction (net:cgi:parse-input) récupère les arguments passés au script CGI et retourne une liste de couples identificateur-valeur de ces arguments. Les identificateurs sont des symboles représentant les noms des champs d'un formulaire HTML, et les valeurs sont les valeurs de ces champs, sous la forme de chaînes de caractères. Cette fonction est compatible avec les deux méthodes pour invoquer les CGI, la méthode POST et la méthode GET, ou une combinaison des deux. Nous verrons plus tard qu'elle traite aussi les documents ayant plusieurs parties (multipart document encoding) et qu'elle gère la transmission de fichiers (upload).

Pour utiliser cette fonction, nous allons écrire le script /home/httpd/cgi-bin/test.cgi qui affiche cette liste de couples : 

#! /usr/local/bin/osm-cgi --banner=off --exec
; OpenScheme lancé sans affichage de la bannière
; pour exécuter le fichier donnée sur la ligne
; de commande par le serveur WEB.

(use 'osm)
(use 'net)

; Récupérations des couples identificateur-valeur.
(define arguments (net:cgi:parse-input))

; Affichage de l'entete HTML.
(display
"Content-type: text/html

<HTML><BODY>
<br><b>ARGUMENTS</b>\n")

; Affichage des couples.
(for-each (lambda (couple)
            (format #t
                    "<br>~a = ~s\n"
                    (car couple)
                    (cdr couple)))
          arguments)

; Affichage du bas de page HTMl.
(display "</BODY></HTML>\n")

Nous pouvons dès à présent tester ce script en entrant l'URL http://localhost/cgi_bin/test1.cgi dans le navigateur.

Si tout se passe bien, nous devrions voir une page WEB avec le mot ARGUMENTS écrit. En cas d'erreur, vous pouvez consulter les journaux du serveur dans les fichiers /var/log/httpd/access_log et /var/log/httpd/error_log. Vérifiez que le programme test1.cgi est bien accessible en lecture et exécution pour tous (sinon, tapez chmod 755 /home/httpd/cgi-bin/test1.cgi) et qu'il se situe dans le répertoire /home/httpd/cgi-bin/. Vérifiez aussi que OpenScheme se situe dans le répertoire /usr/local/bin/osm-cgi et qu'il est bien exécutable pour tous. Pour obtenir OpenScheme, vous pouvez télécharger librement la version Light (qui est parfaitement compatible CGI) sur le site www.open-scheme.com. Décompressez le fichier obtenu osm-*.gz et placez le dans le répertoire /usr/local/bin sous le nom osm-cgi. Rendez le exécutable pour tous ( chmod 755 /usr/local/bin/osm-cgi).

Maintenant, nous allons écrire un formulaire HTML dans /home/httpd/html/test1.html : 

<html>
 <body>
  <! Début do formulaire.
     Le script spécifié par action sera
     invoqué lorsque l'on pressera le bouton.>
  <form action=/cgi-bin/test1.cgi
        method=post>
   <! Zone d'édition.>
   <input type=text
          name=nom
          value=valeur
          size=10>
   <! Bouton OK.>
   <input type=submit
          value=ok>
  </form>
 </body>
</html>

C'est un formulaire à une seule entrée, une zone d'édition, qui invoque le script /cgi_bin/test1.cgi lorsque l'on presse sur son bouton 'ok'. A l'exécution, on voit maintenant que des arguments sont bien associés à une valeur.

Le protocole CGI stipule que des variables sont communiquées aux scripts par l'intermédiaire de variables d'environnement. La liste de ces variables est disponible dans les RFC et les diverses documentations. Pour lire ces variables, OpenScheme dispose de la fonction (os:getenv variable). Pour compléter le script test1.cgi, nous pouvons afficher quelques unes des principales variables d'environnement en ajoutant le code suivant avant la dernière ligne de /home/http/cgi_bin/test1.cgi : 

; A insérer avant la dernière ligne
; de /home/httpd/cgi_bin/test1.cgi

; Affiche le nom et la valeur d'une
; variable d'environnement.
(define (affiche-env variable)
 (let ([valeur (os:getenv variable)])
  (format #t
          "<br>~a = ~s\n"
          variable
          valeur)))

; Quelques sauts de ligne ...
(display "<br><br>\n")
(display "<b>VARIABLES D'ENVIRONNEMENT</b>\n")

; Affichage des principales variable
; d'environnement passées aux scripts CGI.
(affiche-env "AUTH_TYPE")
(affiche-env "CONTENT_LENGTH")
(affiche-env "CONTENT_TYPE")
(affiche-env "GATEWAY_INTERFACE")
(affiche-env "PATH_INFO")
(affiche-env "PATH_TRANSLATED")
(affiche-env "QUERY_STRING")
(affiche-env "REMOTE_ADDR")
(affiche-env "REMOTE_HOST")
(affiche-env "REMOTE_IDENT")
(affiche-env "REMOTE_USER")
(affiche-env "REQUEST_METHOD")
(affiche-env "REQUEST_URI")
(affiche-env "SCRIPT_NAME")
(affiche-env "SERVER_NAME")
(affiche-env "SERVER_PORT")
(affiche-env "SERVER_PROTOCOL")
(affiche-env "SERVER_SOFTWARE")

Nous obtenons maintenant l'affichage : 

ARGUMENTS 
nom = "valeur" 

VARIABLES D'ENVIRONNEMENT 
AUTH_TYPE = #f 
CONTENT_LENGTH = "10" 
CONTENT_TYPE = "application/x-www-form-urlencoded" 
GATEWAY_INTERFACE = "CGI/1.1" 
PATH_INFO = #f 
PATH_TRANSLATED = #f 
QUERY_STRING = "" 
REMOTE_ADDR = "200.201.202.203" 
REMOTE_HOST = #f 
REMOTE_IDENT = #f 
REMOTE_USER = #f 
REQUEST_METHOD = "POST" 
REQUEST_URI = "/cgi-bin/osm1.cgi" 
SCRIPT_NAME = "/cgi-bin/osm1.cgi" 
SERVER_NAME = "localhost" 
SERVER_PORT = "80" 
SERVER_PROTOCOL = "HTTP/1.0" 
SERVER_SOFTWARE = "Apache/1.3"

Emission de code HTML

Lorsqu'un programme CGI affiche un résultat au format HTML, il doit veiller à ce que les caractères accentués soient remplacés par le code HTML correspondant. Par exemple, le code HTML de la lettre 'é' est eacute;. Certains navigateurs se comportent correctement lorsqu'ils rencontrent des caractères accentués. Mais certains autres navigateurs ne supportent ces caractères accentués et il est nécessaire les convertir avant l'affichage.

Pour effectuer cette conversion, OpenScheme propose la fonction (net:cgi:parse-output chaîne) qui remplace les caractères accentués par leur code HTML et retourne une nouvelle chaîne de caractères convertie. Cette fonction remplace aussi les retours chariots de la chaîne par le code HTML qui provoque un saut de ligne dans la page, la séquence (c) par symbol du copyright, la séquence (r) par le symbole du registred et la séquence }(e)} par le symbole de l'euro.

Si on souhaite convertir certaines des sorties effectuées, il faut les passer à la fonction net:cgi:parse-output avant l'affichage : 

#! /usr/local/bin/osm-cgi --banner=off --exec

(use 'osm)
(use 'net)

(define arguments (net:cgi:parse-input))

(display "Content-type: text/html\n\n")
(display "<HTML><BODY>\n")

; Un racourci.
(define & net:cgi:parse-output)

; Affichage avec conversion.
(display (& "\n\n(e) Linux Magazine\n"))
(display (& "\n\nARGUMENTS\n"))

(for-each (lambda (couple)
            (format #t
                    (& "~a = ~s\n")
                    (car couple)
                    (cdr couple)))
          arguments)

(display "</BODY></HTML>\n")

En exécutant ce programme via le navigateur et en affichant le texte source de la page, vous apercevrez les conversions qui ont été effectuées automatiquement.

Mots clefs

Le remplacement de mots clefs dans une chaîne de caractères n'est pas vraiment une fonction du module NET, mais appartient au module STR traitant les chaînes de caractères.

La fonction (str:replace-tokens chaine items) retourne une nouvelle chaîne de caractères à partir de celle passée en argument, dans laquelle les mots clefs spécifiés dans les items ont été remplacés par leur valeur.

Les items sont un vecteur de couples, où chaque couple est formé d`un mot clef et d'une valeur de remplacement. La valeur de remplacement est soit une chaîne de caractères, soit une promesse Scheme (construite avec la fonction standard delay) qui sera évaluée lorsque elle devra effectivement être remplacée.

La fonction s'utilise de la manière suivante : 

Osm> (str:replace-tokens
      "123"
      #(("1" . "un ")
        ("2" . "deux ")
        ("3" . "trois")))
  => "un deux trois"

Il est donc possible de traiter l'ensemble d'un fichier HTML pour y remplacer tous les mots clefs qu'il contient. Les mots clefs ne sont bien sûr pas imposés et n'importe quelle portion de texte peut être définie comme un mot clef. Nous donnons un exemple de programme qui définit une fonction génère attendant comme argument un nom de fichier HTML dans lequel on souhaite remplacer les mots clefs, et un vecteur de mots clefs ; elle lit le fichier HTML ligne par ligne et remplace dans chaque ligne les mots clefs, puis affiche le résultat dans la sortie standard : 

#! /usr/local/bin/osm-cgi --banner=off --exec

(use 'osm)
(use 'net)

; Fonction génératrice
(define (génère fichier.html mots-clef)
 ; Entrée à partir du fichier HTML
 (with-input-from-file
  fichier.html
  (lambda ()
    ; itération sur toutes les lignes
    (let itère ([ligne (read-line)])
     (if (not (eof-object? ligne))
      (begin
       ; Remplacement des mots clefs et
       ; affichage.
       (display (str:replace-tokens
                 ligne
                 tokens))
       (newline)
       ; Ligne suivante...
       (itère (read-line))))))))


; Les mots clefs
(define mots-clef
        #(("mot-clef-1" . "valeur-1")
          ("mot-clef-2" . "valeur-2")
          ...
          ("mot-clef-n" . "valeur-n")))


; Entete HTML
(display "Content-type: text/html\n\n")
(display "<HTML><BODY>\n")

; Génération de la sortie par remplacement
; des mots clefs.
(génère "fichier-avec-mots-clef.html"
        mots-clefs)

; Bas de page HTML
(display "</BODY></HTML>\n")

Il est possible d'automatiser toutes les étapes de la production pour la rendre plus puissante, comme en ajoutant un entête et un bas de page HTML qui sera partagé par toutes les pages produites. La valeur des items est soit une chaîne de caractères constante, soit une promesse Scheme qui sera évaluée que lorsque le remplacement sera nécessaire.

Par exemple : 

Osm> (str:replace-tokens
      "123"
      #(("1" . (delay
                (string-append
                 "expression"
                 " évaluée "
                 " seulement "
                 " lorsque "
                 " nécessaire "))
        ("2" . "")
        ("3" . ".")
        ("4" . (delay
                "Jamais évalué"))))
  => "expression évaluée seulement lorsque nécessaire."

Méthode GET ou méthode POST

Dans notre premier formulaire, nous avons placé le texte method=POST. Nous aurions aussi pu écrire method=GET. La différence entre les deux est la manière avec laquelle les valeurs de champs du formulaire sont passées aux scripts CGI. Dans la première, les informations sont passées dans l'entête de la requête HTTP. Avec cette méthode, le nombre des champs n'est pas limité.

Dans le cas de la méthode GET, les valeurs des champs sont passées sur la ligne de commande du script CGI, avec la forme sectioncript?champ1=valeur1:champs2=valeur2...

Le problème est que la ligne de commande de certains systèmes d'exploitation (en est-ce vraiment ?) est limitée, et il se peut que la ligne de commande soit tronquée. Dans Linux, la ligne de commande peut occuper jusqu'à 64 ko.

Pour cette raison, on préfère utiliser la méthode POST.

OpenScheme reconnaît les deux méthodes, et il permet que les deux modes de passage des arguments soient utilisés simultanément. On pourra par exemple écrire le formulaire : 

<html>
 <body>
  <form action=/cgi-bin/test1.cgi?ident=valeur
        method=post>
   <input type=text
          name=nom
          value=valeur
          size=10>
   <input type=submit
          value=ok>
  </form>
 </body>
</html>

Nous avons donc maintenant terminé la première partie liée à la production de documents HTML en utilisant le remplacement de mots clefs. Le mois prochain, nous aborderons l'inclusion de code Scheme dans les pages HTML, à la manière de PHP ou des ASP.

next up previous contents index
Next: Conclusion Up: Scripts CGI Previous: CGI, base   Contents   Index
© 1993 to 2001 Erian Concept