Les FAQs utiles et les documents relatifs sont :
CGI FAQ
http://www.webthing.com/tutorials/cgifaq.html
Web FAQ
http://www.boutell.com/faq/
WWW Securite FAQ
http://www.w3.org/Security/Faq/
HTTP Spec
http://www.w3.org/pub/WWW/Protocols/HTTP/
HTML Spec
http://www.w3.org/TR/REC-html40/
http://www.w3.org/pub/WWW/MarkUp/
CGI Spec
http://www.w3.org/CGI/
CGI Securite FAQ
http://www.go2net.com/people/paulp/cgi-security/safe-cgi.txt
use CGI::Carp;
warn "This is a complaint";
die "But this one is serious";
L'utilisation suivante de CGI::Carp redirige également les erreurs vers un fichier de votre choix, mais aussi les avertissements durant la phase de compilation en étant place dans un bloc BEGIN.
BEGIN {
use CGI::Carp qw(carpout);
open(LOG, ">>/var/local/cgi-logs/mycgi-log")
or die "Unable to append to mycgi-log: $!\n";
carpout(*LOG);
}
Vous pouvez vous arrangez pour que les erreurs fatales soient retournées au navigateur client, ceci vous permettant d'obtenir un meilleur debogage, mais pouvant paraître confus pour l'utilisateur final.
use CGI::Carp qw(fatalsToBrowser);
die "Bad error here";
Si l'erreur se produit avant même que vous ayez produit les en-têtes HTTP en sortie, le module essayera de les générer pour éviter une erreur 500 du serveur. Les avertissements normaux continueront à être envoyés vers le fichier de log des erreurs du serveur (ou là où vous les avez envoyées via "carpout") préfixés par le nom du script et la date.
Plusieurs personnes essayent une approche simple par les expressions rationnelles, comme "s/<.*?>//g", mais ceci ne fonctionne pas correctement dans de nombreux cas car les marqueurs HTML peuvent continuer après des sauts de lignes, ils peuvent contenir des < ou des > entre guillemets, ou des commentaires HTML peuvent être présents. De plus, ces personnes oublient de convertir les entités comme "<" par exemple.
Voici une ``solution-basique'', qui fonctionne avec la plupart des fichiers :
#!/usr/bin/perl -p0777
s/<(?:[^>'"]*|(['"]).*?\1)*>//gs
Si vous souhaitez une solution plus complète, regardez le programme striphtml se décomposant en 3 étapes à l'adresse http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/striphtml.gz
Voici quelques cas piégeux auxquels vous devriez penser avant de choisir une solution :
<IMG SRC = "foo.gif" ALT = "A > B">
<IMG SRC = "foo.gif"
ALT = "A > B">
<!-- <Un commentaire> -->
<script>if (a<b && a>c)</script>
<# Just data #>
<![INCLUDE CDATA [ >>>>>>>>>>>> ]]>
Si les commentaires HTML incluent d'autres balises, ces solutions échoueraient aussi sur un texte tel que celui-ci :
<!-- Cette section est en commentaire.
<B>You can't see me!</B>
-->
#!/usr/bin/perl -n00
# qxurl - tchrist@perl.com
print "$2\n" while m{
< \s*
A \s+ HREF \s* = \s* (["']) (.*?) \1
\s* >
}gsix;
Cette version n'ajuste pas les URL relatives, ne comprend pas les instructions de base différentes, traite les commentaires HTML, traite les attributs HREF et NAME dans la même balise, comprend les qualificateurs supplémentaires comme TARGET, ou accepte les URL elles-mêmes en arguments. Elle fonctionne aussi à peu près 100 fois plus vite qu'une solution plus ``complète'' utilisant la suite de modules LWP, tel que le programme http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/xurl.gz
$html_code = `lynx -source $url`;
$text_data = `lynx -dump $url`;
Les modules libwww-perl (LWP) du CPAN fournissent une façon plus puissante de le faire. Ils n'ont pas besoin de lynx, mais tout comme lynx, ils peuvent fonctionner à travers les serveurs mandataires (proxy, NDT) :
# version la plus simple
use LWP::Simple;
$content = get($URL);
# ou affiche du HTML depuis un URL
use LWP::Simple;
getprint "http://www.linpro.no/lwp/";
# ou affiche de l'ASCII depuis le HTML d'un URL
# nécessite aussi le paquetage HTML-Tree du CPAN
use LWP::Simple;
use HTML::Parser;
use HTML::FormatText;
my ($html, $ascii);
$html = get("http://www.perl.com/");
defined $html
or die "Can't fetch HTML from http://www.perl.com/";
$ascii = HTML::FormatText->new->format(parse_html($html));
print $ascii;
use LWP::Simple;
use URI::URL;
my $url = url('http://www.perl.com/cgi-bin/cpan_mod');
$url->query_form(module => 'DB_File', readme => 1);
$content = get($url);
Si vous utilisez la méthode POST, créez votre propre agent utilisateur et codez le contenu de façon appropriée.
use HTTP::Request::Common qw(POST);
use LWP::UserAgent;
$ua = LWP::UserAgent->new();
my $req = POST 'http://www.perl.com/cgi-bin/cpan_mod',
[ module => 'DB_File', readme => 1 ];
$content = $ua->request($req)->as_string;
$string = "http://altavista.digital.com/cgi-bin/query?pg=q&what=news&fmt=.&q=%2Bcgi-bin+%2Bperl.exe";
$string =~ s/%([a-fA-F0-9]{2})/chr(hex($1))/ge;
Le codage est un peu plus difficile, car vous ne pouvez pas juste changer aveuglément tous les caractères non alpha-numérique ("\W") en échappements hexadécimaux. Il est important que les caractères ayant une signification spéciale tels que "/" et "?" ne soient pas transformés. La façon la plus simple d'obtenir le résultat escompté n'est probablement pas de réinventer la roue, mais seulement d'utiliser le module URI::Escape disponible sur le CPAN.
Location: http://www.domain.com/newpage
URI: http://www.domain.com/newpage
Notez que les URL relatifs dans ces en-têtes peuvent provoquer des comportements étrange à cause des ``optimisations'' que les serveurs font.
$url = "http://www.perl.com/CPAN/";
print "Location: $url\n\n";
exit;
Pour viser un cadre particulier dans un frameset, incluez le champe ``Window-target:'' dans l'en-tête.
print <<EOF;
Location: http://www.domain.com/newpage
Window-target: <FrameName>
EOF
Pour être conforme aux spécifications, chacune de ces fins de lignes virtuelles devrait être de vraies séquences "\015\012" physiques le temps qu'elles arrivent au navigateur client. À part les scripts NPH, toutefois, cette fin de ligne locale devrait être traduite par votre serveur sous une forme standard, vous ne devriez donc pas avoir de problème à ce niveau, même si vous êtes coincés sous MacOS. Il est probable que personne d'autre ne le remarque.
use HTTPD::UserAdmin ();
HTTPD::UserAdmin
->new(DB => "/foo/.htpasswd")
->add($username => $password);
En bref : utilisez la souillure (voir perlsec), qui s'assure que les données en provenance de l'extérieur de votre script (e.g. des paramètres CGI) ne sont jamais utilisées dans des appels "eval" ou "system". En plus de la souillure, n'utilisez jamais la forme à un seul argument de system() ou d'exec(). À la place, fournissez la commande et les arguments en tant que liste, qui empêche la globalisation par le shell.
$/ = '';
$header = <MSG>;
$header =~ s/\n\s+/ /g; # fusionne les lignes fractionnées
%head = ( UNIX_FROM_LINE, split /^([-\w]+):\s*/m, $header );
Cette solution ne fonctionne pas correctement si, par exemple, vous essayez de mettre à jour toutes les lignes reçues. Une approche plus complète consiste à utiliser le module Mail::Header du CPAN (faisant parti du paquetage MailTools).
Vous verrez beaucoup de programmes CGI qui lisent aveuglément sur STDIN un nombre d'octets égal au CONTENT_LENGTH pour les POSTs, ou saisissent QUERY_STRING pour décoder les GETs. Ces programmes sont très mal écrits. Ils ne marchent que parfois. Ils oublient typiquement de vérifier la valeur de retour de l'appel système read(), ce qui est un péché cardinal. Ils ne traitent pas les requêtes HEAD. Ils ne traitent pas les formulaires en plusieurs parties utilisés pour les envois de fichiers. Ils ne traitent pas les combinaisons GET/POST où les champs de requête se trouvent en plusieurs endroits. Ils ne traitent pas les mots-clés dans la chaîne de la requête.
En deux mots, ce sont de mauvais bidouillages. Résistez-leur à tout prix. S'il vous plaît ne soyez pas tenté de réinventer la roue. À la place, utilisez CGI.pm ou CGI_Lite.pm (disponible sur le CPAN), ou si vous piégés dans le monde sans modules de perl1 .. perl4, vous devriez regarder dans cgi-lib.pl (disponible à http://www.bio.cam.ac.uk/web/form.html).
Assurez-vous de savoir s'il faut utiliser un GET ou un POST dans votre formulaire. Les GETs ne devraient être utilisés que pour quelque chose qui ne modifie pas le serveur. Autrement, vous pouvez obtenir des bases de données sens dessus-dessous et des courriers électroniques répétés. Le joli mot pour ça est ``idempotence''. Ceci veut simplement dire qu'il ne devrait y avoir aucune différence entre faire une requête GET pour un URL particulier et en faire plusieurs. C'est parce que la définition du protocole HTTP dit qu'une requête GET peut être mise en cache par le navigateur, ou le serveur, ou un mandataire intermédiaire. Les requêtes POST ne peuvent pas l'être, parce que chaque requête est indépendante et importante. Typiquement, les requêtes POST changent ou dépendent de l'état du serveur (consultation ou mise à jour d'une base de données, envoi de courrier, ou achat d'un ordinateur).
Sans envoyer un mail à l'adresse et constater s'il y a un humain de l'autre côté pour vous répondre, vous ne pouvez pas déterminer si une adresse est valide. Même si vous appliquez l'en-tête standard d'email, vous pouvez rencontrer des problèmes, car il existe des adresses valides qui ne sont pas compatibles avec la RFC-822 (le standard des en-têtes des mails), et inversement il existe des adresses qui ne sont pas délivrables et qui sont compatibles.
Beaucoup sont tentés d'éliminer de fréquentes adresses email invalides avec une simple expression régulière, comme "/^[\w.-]+\@([\w.-]\.)+\w+$/". C'est une très mauvaise idée. Cependant ceci rejette également beaucoup d'adresses valides, et ne dit rien sur la potentialité de cette adresse à être délivrable, ce n'est donc pas suggéré. À la place regardez : http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/ckaddr.gz , qui effectivement vérifie une compatibilité complète avec les spécifications RFC (excepté les commentaires imbriqués), vérifie qu'il ne s'agit pas d'une adresse que vous ne désirez pas (cad, Bill Clinton ou votre responsable de compte mail), puis s'assure que le nom d'hôte donné peut être trouvé dans les enregistrements MX du DNS. Ce n'est pas très rapide, mais ça marche pour ce que ça essaye de faire.
Notre meilleur conseil pour vérifier l'adresse de quelqu'un est de lui faire entrer deux fois son adresse, tout comme vous le faites pour changer un mot de passe. Ceci élimine habituellement les fautes de frappe. Si les deux versions sont égales, envoyez un courrier à cette adresse avec un message personnel ayant cette allure :
Dear someuser@host.com,
Please confirm the mail address you gave us Wed May 6 09:38:41
MDT 1998 by replying to this message. Include the string
"Rumpelstiltskin" in that reply, but spelled in reverse; that is,
start with "Nik...". Once this is done, your confirmed address will
be entered into our records.
Si vous recevez le message et s'ils ont suivi vos indications, vous pouvez être raisonnablement assuré que l'adresse est réelle.
Une stratégie proche moins ouverte à la tromperie est de leur donner un PIN (numéro d'identification personnel). Enregistrez l'adresse et le PIN (le mieux est qu'il soit aléatoire) pour un traitement ultérieur. Dans le message que vous envoyez, demandez-leur d'inclure le PIN dans leur réponse. Mais si le message rebondit, ou est inclus via un script ``vacances'', il sera là de toute façon. Il est donc plus efficace de leur demander de renvoyer un PIN légèrement modifié, par exemple inversé, ou une unité ajoutée à chaque chiffre, etc.
use MIME::base64;
$decoded = decode_base64($encoded);
Une approche plus directe consiste à utiliser la fonction unpack() avec le formatage ``u'' après quelques translations mineures :
tr#A-Za-z0-9+/##cd; # supprime les caracteres non base-64
tr#A-Za-z0-9+/# -_#; # convertit dans le format uuencode
$len = pack("c", 32 + 0.75*length); # calcule la longueur en octets
print unpack("u", $len . $_); # uudecode et affiche
use Sys::Hostname;
$address = sprintf('%s@%s', getpwuid($<), hostname);
La politique de la compagnie sur les adresses email peut signifier que ceci génère des adresses que le système de mail de la compagnie n'acceptera pas, ainsi vous devriez demander les adresses email des utilisateurs quand ceci compte. Qui plus est, tous les systèmes sur lesquels fonctionne Perl n'acceptent pas ces informations comme sur Unix.
Le module Mail::Util du CPAN (faisant partie du package MailTools) procure une fonction mailaddress() qui essaye de créer l'adresse email d'un utilisateur. Il effectue une démarche plus intelligente que le code précédent, utilisant des informations fournies quand le module a été installé, mais cela peut rester incorrect. Encore une fois, la meilleure manière est souvent de simplement poser la question à l'utilisateur.
open(SENDMAIL, "|/usr/lib/sendmail -oi -t -odq")
or die "Can't fork for sendmail: $!\n";
print SENDMAIL <<"EOF";
From: User Originating Mail <me\@host>
To: Final Destination <you\@otherhost>
Subject: A relevant subject line
Body of the message goes here after the blank line
in as many lines as you like.
EOF
close(SENDMAIL) or warn "sendmail didn't close nicely";
L'option -oi empêche sendmail d'interpréter une ligne constituée d'un seul point comme une ``fin de message''. L'option -t lui dit d'utiliser les en-têtes pour décider à qui envoyer le message, et -odq lui dit de placer le message dans la file d'attente. Cette dernière option signifie que votre message ne sera pas immédiatement envoyé, donc ne la mettez pas si vous voulez un envoi immédiat.
Alternativement, des approches moins pratiques comprennent l'appel direct à mail (parfois appelé mailx) ou la simple ouverture du port 25 pour avoir une conversation intime rien qu'entre vous et le démon SMTP distant, probablement sendmail.
Ou vous pourriez utiliser le module Mail::Mailer du CPAN :
use Mail::Mailer;
$mailer = Mail::Mailer->new();
$mailer->open({ From => $from_address,
To => $to_address,
Subject => $subject,
})
or die "Can't open: $!\n";
print $mailer $body;
$mailer->close();
Le module Mail::Internet utilise Net::SMTP qui est moins Unix-centrique que Mail::Mailer, mais moins fiable. Évitez les commandes SMTP crues. Il y a de nombreuses raisons pour utiliser un agent de transport de mail comme sendmail. Celles-ci comprennent la mise en file d'attente, les enregistrement MX, et la sécurité.
#!/usr/bin/perl
# bysub1 - simple sort by subject
my(@msgs, @sub);
my $msgno = -1;
$/ = ''; # lit un paragraphe
while (<>) {
if (/^From/m) {
/^Subject:\s*(?:Re:\s*)*(.*)/mi;
$sub[++$msgno] = lc($1) || '';
}
$msgs[$msgno] .= $_;
}
for my $i (sort { $sub[$a] cmp $sub[$b] || $a <=> $b } (0 .. $#msgs)) {
print $msgs[$i];
}
Ou de façon plus succincte,
#!/usr/bin/perl -n00
# bysub2 - awkish sort-by-subject
BEGIN { $msgno = -1 }
$sub[++$msgno] = (/^Subject:\s*(?:Re:\s*)*(.*)/mi)[0] if /^From/m;
$msg[$msgno] .= $_;
END { print @msg[ sort { $sub[$a] cmp $sub[$b] || $a <=> $b } (0 .. $#msg) ] }
Le module Sys::Hostname (qui fait partie de la distribution standard Perl), vous donnera le nom de machine, avec lequel vous pourrez trouvez l'adresse IP (en supposant que vous ayez un DNS en état de fonctionnement) avec un appel à gethostbyname().
use Socket;
use Sys::Hostname;
my $host = hostname();
my $addr = inet_ntoa(scalar(gethostbyname($name)) || 'localhost');
Probablement la manière la plus simple de connaître votre domaine DNS est de le récupérer dans /etc/resolv.conf, du moins sous Unix. Bien évidemment cela suppose plusieurs choses à propos de la configuration de votre /etc/resolv.conf, notamment qu'il existe.
(Nous continuons à espérer une bonne méthode pour connaître le domaine DNS pour les systèmes autre que Unix).
perl -MNews::NNTPClient
-e 'print News::NNTPClient->new->list("newsgroups")'
Lorsque ce travail est inclus comme un élément de la distribution standard de Perl ou comme une partie de sa documentation complète sous forme imprimée ou autrement, il ne peut être distribué que dans les limites fixées par la Perl's Artistic License. Toute distribution de ce fichier ou de ses dérivés hors de cet ensemble nécessite un accord particulier avec le titulaire des droits (voir perlfaq).
Indépendemment de sa distribution, tous les exemples de code de ce fichier sont ici placés dans le domaine public. Vous êtes autorisés et encouragés à utiliser ce code dans vos programmes que ce soit pour votre plaisir ou pour un profit. Un simple commentaire dans le code en précisant l'origine serait de bonne courtoisie mais n'est pas obligatoire.