SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
 |
Fonctions pour la gestion de fichiers et de répertoires |
|
|
 | |
Perl vient de l'univers Unix et c'est la raison pour laquelle les fonctions touchant la gestion de fichiers de fichiers et de répertoires sont orientées également sur les propriétés typiques de Unix. Quelques unes de ces fonctions ne sont applicables que si le script Perl est exécuté sur un système Unix. Les fonctions qui peuvent être transmises à d'autres systèmes d'exploitation fonctionnent également sous Unix. Au cours des descriptions des différentes fonctions, l'attention sera attirée si des restrictions existent pour certains types de systèmes d'exploitation.
Il existe également d'autres fonctions pour la gestion de fichiers, par exemple pour copier et déplacer des fichiers, mais elles ne font pas partie du noyau de Perl. Ces fonctions sont accessibles par le 
module standard FILE.
Les fonctions décrites ici attendent comme paramètre des mentions de chemin. Utilisez toujours comme signe de séparation entre les noms de répertoires la barre oblique simple pour des raisons de compatibilité entre systèmes d'exploitation, même pour les scripts Perl qui doivent tourner sous MS Windows. Perl les transforme sous MS Windows en interne, en barres obliques inversées spécifiques à Microsoft. Exemple:
|
N'utilisez des mentions relatives que lorsque le répertoire de travail actuel vous est connu.
Pour rechercher le répertoire de travail actuel en Perl, vous pouvez noter:
use Cwd; my $repertoire_travail = cwd; |
Dans la scalaire $repertoire_travail figure alors ensuite le chemin complet du répertoire de travail actuel. Pour le faire, le module standard cwd est utilisé.
Beaucoup des fonctions décrites ici attendent comme paramètre une mention de droits.
Dans les systèmes Unix tous les éléments d'un système de fichiers ont des droits. Chaque fichier, chaque répertoire appartient à un utilisateur, et chaque utilisateur fait partie d'un groupe d'utilisateurs. Celui qu'on appelle le super-utilisateur, l'utilisateur avec ce qu'on nomme l'identification racine, peut organiser les utilisateurs et groupes d'utilisateurs et attribuer les données d'identification pour les différents utilisateurs du système.
Un utilisateur qui se connecte à un système Unix reçoit du système d'exploitation une identification d'utilisateur individuelle, la User-ID (UID). De la même façon chaque groupe d'utilisateurs reçoit une Group-ID (GID). les deux ID sont des numéros. Dans certaines des fonctions décrites ici, ces ID jouent un rôle. Ces fonctions ne sont alors applicables, en règle générale, que si le script Perl doit tourner dans un environnement Unix.
Le système sait toujours quel utilisateur connecté crée un fichier ou un répertoire. Le fichier ou le répertoire appartiennent alors à cet utilisateur ou à son groupe primaire d'utilisateurs. En plus de cela, il est aussi possible sur des systèmes Unix, de fixer les droits d'accès de l'utilisateur détenteur, de son groupe d'utilisateurs primaire et des autres ("reste du monde"), et ce pour chaque fichier ou chaque répertoire. Ici une distinction est faite entre les droits en lecture, en écriture et les droits en exécution. Chacune de ces trois sortes de droits (lecture, écriture, exécution) peut être fixée individuellement sur "oui" ou "non" pour chacun des trois groupes d'utilisateurs (propriétaire, groupe auquel il appartient et reste du monde). La représentation de ces droits a lieu habituellement de deux façons: soit comme chaîne de caractères de 3 fois 3, donc 9 caractères ou bien en octal avec 3 chiffres.
Représentation comme chaîne de caractères (exemples):
rwxrwxrwx rw-r--r-- rwx------ |
La lettre r figure pour la lecture (read), w pour l'écriture (write), et x pour l'exécution (execute). Si la lettre est mise, le droit correspondant est accordé. Si le droit correspondant n'est pas accordé, un trait d'union - est noté à la place. Les trois premiers des neuf caractères représentent les droits en lecture, en écriture et en exécution pour l'utilisateur propriétaire du fichier, les trois caractères suivants, les droits en lecture, en écriture et en exécution pour son groupe, et les trois derniers caractères les droits en lecture, en écriture et en exécution pour le "reste du monde";.
La valeur rwxrwxrwx signifie: les trois types d'utilisateurs (utilisateur propriétaire, groupe auquel il appartient et reste du monde) ont les trois sortes de droits sur le fichier.
La valeur rw-r--r-- signifie: l'utilisateur propriétaire a les droits en "lecture " et en "écriture", mais pas en "exécution", son groupe et le reste du monde n'ont que le droit en "lecture", mais pas les droits en "écriture" et en "exécution".
La valeur rwx------ signifie: l'utilisateur propriétaire a tous les droits, son groupe et le reste du monde n'en ont absolument aucun.
Représentation comme nombre octal (mêmes exemples qu'auparavant):
0777 0644 0700 |
Pour cette représentation qui est exigée par le plupart des fonctions décrites ici, le nombre est précédé par 0, ce qui permet à Perl d'interpréter le nombre comme nombre octal. Le nombre proprement-dit est constitué des trois chiffres suivants. Dans le système octal, seuls sont permis les chiffres entre 0 et 7. Le premier chiffre figure pour les droits de l'utilisateur propriétaire, le deuxième pour les droits de son groupe et le troisième pour le "reste du monde". Le droit en "lecture" donne 4 "points", le droit en écriture 2 points et le droit en "exécution" 1 point. C'est en additionnant les points que l'on obtient les droits respectifs.
La valeur 0777 signifie: Les trois types d'utilisateurs (utilisateur propriétaire, groupe auquel il appartient et reste du monde) ont les trois sortes de droits sur le fichier (4+2+1).
La valeur 0644 signifie: l'utilisateur propriétaire a les droits en "lecture " et en "écriture" (4+2), son groupe et le reste du monde n'ont que les droits en "lecture" (4).
La valeur 0700 signifie: l'utilisateur propriétaire a tous les droits, son groupe et le reste du monde n'en ont absolument aucun.
Comme aide pour les droits sur les fichiers, vous pouvez utiliser le modificateur Unix de droits sur les fichiers (chmod).
|
La méthode la plus simple et la plus rapide d'accéder de façon ciblée à certaines propriétés d'un fichier ou d'un répertoire est celle que Perl propose avec ses opérateurs de test fichier. Certains des opérateurs de test fichier renvoient un nombre, par exemple la taille d'un fichier en octets, d'autres seulement si une affirmation est vraie ou non. Vous trouverez le récapitulatif des opérateurs de test fichier dans le
tableau des opérateurs de test fichier.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $fichier_texte = "/usr/bin/myprog/readme.txt"; my $fichier_inconnu = "/usr/bin/myprog/doit"; my $fichier_Perl = "/usr/webcgi-local/montant.pl"; my $fichier_log = "/usr/web/logs/ce_jour.log"; print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><body>\n"; print "Le fichier texte a une taille de ",-s $fichier_texte," octets<br>\n"; printf "La dernière modification du fichier texte remonte à %.3f jours <br>\n",-M $fichier_texte; print "Le fichier inconnu ",-d $fichier_inconnu ? "est un répertoire<br>\n" : "n'est pas un répertoire<br>\n"; print "Le fichier Perl ",-e $fichier_Perl ? "existe<br>\n" : "n'existe pas<br>\n"; print "Il y a eu des accès" if not -z $fichier_log; print "</body></html>\n"; |
Tous les opérateurs de test fichier pour s'enquérir sur les propriétés comportent un signe moins suivi d'une lettre sans espace les séparant. Derrière suit un espace et la mention du fichier désiré avec le nom de chemin complet si c'est indispensable.
Dans l'exemple 1 ci-dessus trois scalaires sont définies et sauvegardent les noms de fichier avec la mention de chemin. Ensuite, du code HTML est envoyé au navigateur. Ici, diverses affirmations sur les propriétés des trois fichiers sont concernées.
La première instruction print contient comme paramètre un opérateur de test fichier (voir aussi à ce sujet la syntaxe de print). Dans l'instruction, la taille du fichier est recherchée par l'application de -s $fichier_texte et elle est sortie à l'endroit correspondant.
Dans la deuxième commande, un appel de printf, il est recherché avec -M $fichier_texte depuis combien de jours le fichier n'a plus été modifié. Cette valeur est elle aussi sortie. Comme -M renvoie un nombre à virgule flottante, la sortie est ramenée à trois chiffres après la virgule à l'aide de la fonction printf.
Dans les deux commandes print suivantes, vous avez une construction typique montrant comment les opérateurs de test fichier qui ne renvoient que "vrai" ou "faux" sont appliqués. Pour leur emploi intervient dans les deux cas une simple requête soit..., soit.... Dans le premier cas il est demandé avec un opérateur de test fichier -d si le fichier inconnu sans extension est un répertoire ou un fichier normal. Dans le deuxième cas il est demandé avec -e si le fichier Perl existe ou non.
Le dernier exemple montre comment un opérateur de test fichier peut être placé dans une condition placée après - là aussi une construction typique. L'exemple recherche à l'aide de l'opérateur de test fichier -z, si le fichier est vide ou pas. S'il n'est pas vide un message est sorti que des accès ont déjà eu lieu.
Les opérateurs de test fichier peuvent aussi s'appliquer à des descripteurs de fichier attribués à la place des mentions directes sur le fichier. Quand par exemple, vous ouvrez un fichier en lecture avec open(FILE,"<fichier.htm"), vous pouvez rechercher la taille du fichier avec -s FILE.
|
|
|
Fait d'un répertoire le répertoire de travail actuel. Il est ainsi possible après être passé dans un répertoire, d'ouvrir les fichiers qu'il contient sans se soucier du nom de chemin.
Attend comme paramètre:
1. le nom de chemin et répertoire du répertoire dans lequel il faut passer. Il peut s'agir d'une mention de chemin relative ou absolue.
Il est aussi possible de ne transmettre aucun paramètre. Dans ce cas, la fonction passe dans le répertoire qui est sauvegardé dans la variable d'environnement HOME.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
chdir("/usr/txt/rfc");
open(FICHIER,"<rfc1867.txt");
my @lignes = <FICHIER>;
close(FICHIER);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body><pre>\n";
print "@lignes";
print "</pre></body></html>\n";
|
L'exemple change de répertoire avec chdir et passe dans le répertoire /usr/local/txt/rfc, donc dans un sous-répertoire déterminé du répertoire racine. Là un fichier est ouvert, lu et refermé (explications sur ces commandes voir open). Ensuite, du code HTML est envoyé au navigateur et sort les lignes du fichier lu.
|
|
fixe les droits en lecture, en écriture et en exécution d'un ou plusieurs fichiers pour l'utilisateur, le groupe d'utilisateurs et le reste du monde (spécifique à Unix).
Attend comme paramètre:
1. une Mention de droits pour fichiers et répertoires. La valeur doit être transmise sous forme numérique octale, et pas sous forme de chaîne de caractères!
2. à n. un ou plusieurs fichiers ou répertoires pour lesquels ces droits doivent être fixés, avec le nom de chemin et répertoire si nécessaire.
Renvoie le nombre des modifications effectuées.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $repertoire = "/usr/web/docs/cgi-bin";
chdir($repertoire);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my @fichiers = glob("*.pl");
my $fichier;
foreach $fichier (@fichiers) {
chmod(0755,$fichier);
print "$fichier fixé à 0755<br>\n";
}
print "</body></html>\n";
|
L'exemple fixe les droits de tous les fichiers Perl d'un répertoire CGI sur 0755 - ce qui est un réglage judicieux pour les scripts CGI sur de nombreux serveurs. Dans ce but, tous les fichiers du répertoire $repertoire (le répertoire CGI) sont choisis avec glob. La liste @fichiers, dans laquelle figurent ensuite les fichiers choisis, est alors traitée dans une boucle foreach. Avec chmod(0755,$fichier) le fichier Perl respectivement actuel se verra attribuer les droits désirés. Pour le contrôle, le script en exemple sort les fichiers qui ont été modifiés.
|
|
Chaque fichier sous Unix a un propriétaire qui est identifié par deux nombres: l'identification utilisateur personnelle (User-ID), (UID) et l'identification du groupe auquel il appartient (Group-ID) (GID). La fonction change le propriétaire et le groupe de propriétaires d'un ou de plusieurs fichiers. Pour ce faire, une identification-racine est indispensable sur la plupart des systèmes Unix.
Attend comme paramètre:
1. l'UID numérique (User-ID du propriétaire),
2. la GID numérique (Group-ID du groupe de propriétaires),
3. à n. un ou plusieurs fichiers pour lesquels doivent s'appliquer l'UID et la GID mentionnées, si nécessaire avec le Nom de chemin et répertoires.
Renvoie le nombre des modifications effectuées.
#!/usr/bin/perl -w
use strict;
chdir("/usr/data/web/htdocs");
opendir(DIR, "/usr/data/web/htdocs") || die "$!\n";
my @elements = readdir(DIR);
closedir(DIR);
foreach (@elements) {
chown(1034, 518, $_) if -f $_;
}
|
L'exemple modifie la propriété pour tous les fichiers réguliers du répertoire imaginaire /usr/data/web/htdocs pour l'utilisateur avec l'User-Id 1034 et la Group-Id 518.
|
|
Détermine un nouveau répertoire comme répertoire racine "virtuel". Les mentions de chemin absolues qui commencent par /, s'y réfèrent ensuite. Sur la plupart des systèmes Unix, une identification racine est indispensable pour appliquer cette fonction.
Attend comme paramètre:
1. le nom de chemin et répertoires du répertoire qui doit être le répertoire racine. Il peut s'agir d'une mention de chemin relative ou absolue.
Il est aussi possible de ne transmettre aucun paramètre. Dans ce cas, le contenu de la variable prédéfinie $_ est interprété comme nom de chemin du répertoire désiré.
#!/usr/bin/perl -w
use strict;
chroot("/usr/local/web/domains/tralalere");
chdir("/");
opendir(DIR, ".");
my @elements = readdir(DIR);
closedir(DIR);
foreach(@elements) {
print "$_\n";
}
|
L'exemple fixe comme nouveau répertoire racine, le chemin /usr/local/web/domains/tralalere. Ensuite le script passe dans le nouveau répertoire racine ("/") avec chdir. Pour le contrôle, le script lit le répertoire actuel (".") et dresse ensuite la liste des éléments de répertoire lus (voir pour les explications sur ces commandes opendir).
|
|
Choisit dans un répertoire tous les fichiers qui correspondent à un certain modèle de nom de fichier. C'est infiniment plus simple que d'opérer avec les fonctions opendir, readdir et closedir. L'inconvénient de glob est en effet que cette fonction démarre une console Unix pour arriver à son résultat. C'est pourquoi la fonction n'est disponible que sur des systèmes Unix de même qu'elle n'est exécutable que si le script a suffisamment de droits pour démarrer la console. Il y a cependant dans les Modules pour la gestion de fichiers un module qui exécute complètement l'algorithme de glob en Perl.
Attend comme paramètre:
1. le modèle de nom de fichier si nécessaire avec le nom de chemin et répertoires.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @fichiers_HTML = glob("/usr/web/docroot/*.htm");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
foreach (@fichiers_HTML) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Le script en exemple choisit dans le répertoire /usr/web/docroot tous les fichiers dont l'extension est htm. Pour le contrôle, le script envoie du code HTML au navigateur et sort tous les fichiers trouvés.
Le tableau suivant contient des exemples de modèles de noms de fichiers:
|
|
|
La fonction link qui correspond à la commande Unix ln, fait, du point de vue de l'utilisateur, une copie d'un fichier. Il s'agit cependant en interne comme avant d'un seul et même fichier qui somme toute peut être maintenant trouvé sous deux noms différents (et le cas échéant à deux emplacements dans l'arborescence). Si le fichier est modifié à l'un des endroits où il est représenté, la modification s'applique également aux autres endroits où il est représenté. Si l'un des fichiers est effacé (par exemple avec unlink), les autres représentations du fichier n'en sont pas affectées. Ce n'est que lorsque la dernière représentation du fichier est effacée que le fichier est effacé définitivement.
Attend comme paramètre:
1. le fichier déjà existant duquel une nouvelle représentation doit être créée, si nécessaire avec le nom de chemin et répertoires,
2. la nouvelle représentation à créer du fichier, si nécessaire avec le nom de chemin.
Renvoie 1 quand l'opération a été couronnée de succès et 0, si elle ne l'a pas été (par exemple parce il n'y avait aucun droit en écriture dans le répertoire cible).
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $succes = link("single.txt","../double.txt");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
$succes ? print "succès" : print "échec";
print "</body></html>\n";
|
L'exemple applique la fonction link pour créer une nouvelle représentation du fichier single.txt du répertoire actuel, qui apparaît dans le répertoire parent (../) sous le nom double.txt. La valeur renvoyée est sauvegardée dans la scalaire $succes. Pour le contrôle, l'exemple envoie du code HTML au navigateur et sort à l'aide d'une Simple requête soit..., soit... l'état du résultat de l'opération.
|
|
Cette fonction fait la même chose que la fonction stat. S'y référer pour une description plus précise et un exemple.
À la différence de stat, lstat ne recherche pas les propriétés d'un fichier, mais d'un lien à un fichier, de ce qu'on appelle un lien symbolique. Quand il ne s'agit pas d'une représentation d'un fichier (donc si le fichier n'apparaît qu'une fois dans l'arborescence), à l'appel de lstat sera lancé automatiquement en interne un appel normal de stat. lstat englobe donc également les représentations de fichiers à la différence de stat, raison pour laquelle il est davantage employé que stat dans la pratique.
|
|
Crée un nouveau répertoire et permet d'attribuer à ce nouveau répertoire, les droits en écriture, en lecture et en exécution (actif seulement pour les systèmes Unix).
Attend comme paramètre:
1. le nom du nouveau répertoire si nécessaire avec le nom de chemin et répertoires.
2. une mention de droits pour fichiers et répertoires. La valeur doit être transmise exprimée sous forme numérique en octal, et non pas comme chaîne de caractères! Pour rechercher le nombre octal désiré, vous pouvez utiliser le modificateur Unix de droits sur les fichiers (chmod) dans les petits assistants.
Sur les systèmes qui ne connaissent pas la gestion des droits Unix, donc par exemple sous MS Windows, le deuxième paramètre n'a pas lieu d'être.
Renvoie 1 ou bien TRUE quand l'opération est couronnée de succès et 0 ou bien FALSE, si la création du répertoire s'est avérée impossible (par exemple faute de droits en écriture dans le répertoire où le sous-répertoire devait être créé). Le texte exact de l'erreur peut être recherché dans ce cas par la variable prédéfinie $!.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @arborescence = (
"textes",
"textes/correspondance",
"textes/factures",
"textes/factures/vieux",
"textes/factures/actuel",
"graphiques",
"graphiques/photos",
"graphiques/photos/autres",
"graphiques/cliparts",
);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
chdir("/temp");
foreach(@arborescence) {
mkdir($_,0777);
print "Sous-répertoire <b>$_</b> créé<br>\n";
}
print "</body></html>\n";
|
L'exemple définit une liste nommée @arborescence. Y sont sauvegardés les éléments qui représentent une structure arborescente à créer. Plus bas dans le script d'exemple, cette liste est traitée dans une boucle foreach. Ici chacun des différents répertoires est créé avec mkdir. Le répertoire respectivement actuel de la liste se trouve à l'intérieur de la boucle dans $_. Comme deuxième paramètre, le nombre octal 0777 est transmis. Ainsi, tous les utilisateurs des répertoires reçoivent tous les droits. Le script en exemple envoie du code HTML au navigateur et sort pour chacun des répertoires créés une phrase adéquate.
|
|
Lit la valeur d'un fichier-lien symbolique. Ce sont des fichiers-liens qui ont été créés par exemple à l'aide de symlink.
Attend comme paramètre:
1. le nom du fichier-lien symbolique si nécessaire avec le nom de chemin et répertoires.
Il est aussi possible de ne transmettre aucun paramètre. Dans ce cas, c'est le contenu de la variable prédéfinie $_ qui est employé.
renvoie le chemin complet du fichier auquel le fichier-lien se réfère. En cas d'erreur, la fonction renvoie undefined et écrit le texte de l'erreur dans la variable prédéfinie $!. Sur les systèmes d'exploitation qui ne connaissent pas les liens symboliques, donc par exemple sous MS Windows, l'appel de cette fonction provoque une erreur grave.
#!/usr/bin/perl
use strict;
use CGI::Carp qw(fatalsToBrowser);
chdir("/tmp");
symlink("/usr/local/webdocs/index.htm","webindex.sym");
my $contenu = readlink("webindex.sym");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "Contenu du fichier symbolique: $contenu\n";
print "</body></html>\n";
|
Le script en exemple passe d'abord dans le répertoire /tmp avec chdir. Là il créée avec symlink un fichier-lien symbolique nommé webindex.sym qui est un lien symbolique au fichier /usr/local/webdocs/index.htm. La valeur qui est attribuée au fichier symbolique est finalement lue avec readlink. Pour le contrôle, le script en exemple envoie du code HTML au navigateur. Ici est sorti le nom de chemin au fichier lié attribué à webindex.sym.
|
|
Attend comme paramètre:
1. le nom d'un fichier ou d'un répertoire à renommer, si nécessaire avec le Nom de chemin et répertoires.
2. le nouveau nom du fichier ou du répertoire si nécessaire avec le nouveau nom de chemin.
Si le premier paramètre est un fichier et le deuxième paramètre le nom d'un autre répertoire le fichier est déplacé dans cet autre répertoire. Il n'est cependant pas possible avec cette fonction de mentionner comme premier et deuxième paramètres deux répertoires différents pour déplacer le premier répertoire dans le second,.
Renvoie true quand l'opération a été couronnée de succès et false dans le cas contraire.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
chdir("/htmldocs");
opendir(DIR,".");
my @elements = readdir(DIR);
closedir(DIR);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $element;
my $nom;
my $nouvel_element;
foreach $element (@elements) {
if($element =~ /(.+)\.htm/) {
$nom = $1;
$nouvel_element = $nom.".html";
rename($element,$nouvel_element);
print "$element renommé en $nouvel_element<br>\n";
}
}
print "</body></html>\n";
|
L'exemple fait en sorte que tous les fichiers d'un répertoire qui se terminent par l'extension .htm , soient renommés en fichiers du même nom se terminant avec l'extension .html.
Le script passe d'abord dans le répertoire /htmldocs avec chdir. Ensuite il lit ce répertoire actuel (".") et le copie dans la liste @elements (voir les explications sur ces commandes opendir). Le script de l'exemple envoie du code HTML au navigateur. Ici, les éléments du répertoire lu sont traités dans une boucle foreach. Pour chaque élément il est vérifié s'il s'agit d'un fichier avec l'extension .htm. Si oui, le nom proprement-dit du fichier est sauvegardé dans $nom et un nouveau nom de fichier constitué de le valeur de $nom et de l'extension .html est défini. Enfin, la fonction rename est appelée. Ici l'élément tel qu'il était jusqu'alors, donc un fichier .htm, est renommé en un nouvel élément donc un fichier au nom proprement-dit identique mais dont l'extension est .html. Pour le contrôle, le script sort tous les nouveaux noms affectés.
|
|
Attend comme paramètre:
1. le nom du répertoire à effacer si nécessaire avec le nom de chemin et répertoires.
Le répertoire doit être vide, faute de quoi il ne peut pas être effacé avec cette fonction.
Renvoie 1 quand le répertoire a été effacé. Dans le cas où une erreur est survenue, c'est 0 qui est renvoyé et le message d'erreur figure dans la variable prédéfinie $!.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $repertoire = $ENV{'QUERY_STRING'};
my $resultat = rmdir($repertoire);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
if($resultat == 1) {
print "$Répertoire effacé!";
}
else {
print "$!";
}
print "</body></html>\n";
|
Le script transmet un paramètre lors de l'appel qui est noté par l'URI derrière un point d'interrogation à l'appel. Le paramètre transmis est constitué par la mention de chemin du répertoire à effacer. Exemple:
/mydocs/textes/dechets.
Le script essaie d'effacer le répertoire transmis. La valeur renvoyée par la tentative est sauvegardée dans la scalaire $resultat.
Enfin, le script envoie su code HTML au navigateur. Ce faisant, il est sorti si le répertoire transmis a été effacé avec succès ou non. Si ce n'est pas le cas, le message d'erreur généré est sorti.
|
|
Recherche les différentes propriétés d'un fichier en une seule fois sous forme de liste. La plupart de ces propriétés sont spécifiques à Unix. Certaines de ces propriétés peuvent certes également être questionnées sur d'autres plates-formes, pourtant il est à vrai dire plus simple pour le faire d'utiliser les opérateurs de test fichier pour fichiers et répertoires. La fonction stat ne peut pas, contrairement à lstat, s'appliquer aux représentations de fichiers nais seulement aux "originaux" de fichiers.
Attend comme paramètre:
1. le nom du fichier désiré, si nécessaire avec le nom de chemin et répertoires. En alternative, le nom d'un descripteur de fichier peut aussi être transmis.
Renvoie une liste de 13 éléments. Chaque élément contient une certaine propriété de fichier recherchée.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $fichier = "/usr/webperldoc/index.html"; my @Info = stat($fichier); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body><pre>\n"; print "<b>Fichier:</b> $fichier\n"; print "<b>Numéro de périphérique:</b> $Info[0]\n"; print "<b>Numéro Inode:</b> $Info[1]\n"; printf "<b>Droits d'accès:</b> %o\n", $Info[2]; print "<b>Nombre de liens au fichier:</b> $Info[3]\n"; print "<b>User-ID du propriétaire:</b> $Info[4]\n"; print "<b>Group-ID du propriétaire:</b> $Info[5]\n"; print "<b>Numéro brut du périphérique:</b> $Info[6]\n"; print "<b>Taille du fichier:</b> $Info[7]\n"; print "<b>Date du dernier accès:</b> $Info[8]\n"; print "<b>Date de la dernière modification:</b> $Info[9]\n"; print "<b>Date de la modification Inode:</b> $Info[10]\n"; print "<b>Taille de bloc idéale:</b> $Info[11]\n"; print "<b>Nombre de blocs occupés:</b> $Info[12]\n"; print "</pre></body></html>\n"; |
L'exemple recherche pour un fichier déterminé (/usr/webperldoc/index.html) avec stat les propriétés disponibles du fichier. La valeur renvoyée par la fonction est sauvegardée dans une liste @Info. L'exemple envoie du code HTML au navigateur en dressant la liste des 13 propriétés distinctes qui peuvent être appelées par $Info[0] jusqu'à $Info[12]. Le tableau suivant contient des informations complémentaires sur les différentes propriétés.
|
|
|
Crée un lien symbolique à un fichier sauvegardé ailleurs. L'élément de répertoire ainsi créé apparaît à la différence d'un élément qui a été créé avec link, non pas comme une représentation effective de l'autre fichier mais comme une liaison à l'autre fichier (spécifique à Unix).
Attend comme paramètre:
1. le fichier existant auquel un lien symbolique doit être créé, si nécessaire avec le nom de chemin et répertoires,
2. le fichier-lien symbolique à créer si nécessaire avec le nom de chemin et répertoires.
Renvoie 1 quand l'opération a été couronnée de succès et 0, quand elle ne l'a pas été. Sur les systèmes d'exploitation qui ne connaissent pas les liens symboliques, cette fonction peut conduire à une erreur grave lors de l'exécution du script!
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $symlink_exists = eval { symlink("",""); 1 };
if($symlink_exists) {
symlink("/usr/local/people/serge.htm","/usr/local/links/serge.link");
}
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
opendir(DIR, "/usr/local/links");
my @fichiers = readdir(DIR);
closedir(DIR);
foreach (@fichiers) {
print "$_<br>\n";
}
print "</body></html>\n";
|
L'exemple vérifie d'abord à l'aide de la fonction eval, si le système d'exploitation sous lequel le script est exécuté, les liens symboliques sont possibles. Utilisez pour une telle vérification, la commande telle qu'elle est notée dans l'exemple. Dans la valeur renvoyée qui est sauvegardée dans l'exemple dans la scalaire $symlink_exists, se trouve la valeur 1 (true), au cas où les liens symboliques sont possibles. Avec la construction if($symlink_exists) l'exécution conditionnelle de symlink est alors possible. Dans l'exemple un fichier-lien nommé serge.link est créé et pointe sur le fichier original serge.htm qui se trouve dans un autre répertoire. L'exemple lit pour le contrôle, le répertoire dans lequel le fichier lien a été créé (Explications sur ces commandes voir opendir) et envoie le code HTML correspondant au navigateur.
|
|
Cette fonction n'est significative que pour les systèmes Unix. Quand sous Unix un nouveau fichier est écrit, les droits d'accès qui lui sont attribués sont influencés par l'Umask du processus actuel en cours (par exemple le script qui créée le fichier). Par l'appel de la fonction umask vous pouvez modifier l'Umask du processus en cours et influencer ainsi les droits d'accès des fichiers nouvellement créés.
Attend comme paramètre:
1. un masque de bits pour les mentions de droits pour fichiers et répertoires. La valeur doit être transmise exprimée sous forme numérique en octal. Chaque bit posé dans un masque de bits fait en sorte que le bit correspondant dans un fichier créé par le processus en cours est éteint.
Renvoie l'ancienne valeur de l'Umask.
#!/usr/bin/perl -w use strict; use Fcntl; sysopen(FICHIER,"/usr/web/temp/test.txt", O_CREAT,0666); umask(0077); sysopen(FICHIER2,"/usr/web/temp/test2.txt", O_CREAT,0666); open(LS,"ls -la /usr/web/temp |"); print while(<LS>); close(FICHIER); close(FICHIER2); close(LS); |
L'exemple crée deux fichiers nommés test.txt et test2.txt avec deux appels de sysopen. Pour les deux fichiers a été mentionnée comme mention de droits désirés 0666. Entre les deux appels de sysopen figure cependant un appel de umask. À la fonction est transmis ici 077 comme nombre octal précédé d'un 0. Ceci a pour effet que pour le fichier test2.txt les droits d'accès effectifs sont fixés à 0600. Pour le contrôle, le script envoie au navigateur le résultat de la commande Unix ls pour le répertoire dans lequel les deux fichiers ont été créés.
La façon d'agir de umask est plus facile à comprendre quand on décrypte le modèle de bits du nombre octal en le comparant à l'écriture des droits d'accès sous forme de chaîne de caractères.
Le modèle de bits du nombre octal 077 équivaut à: 000111111 (un 7 correspond à 111 en binaire!).
La façon d'écrire 0666 sous forme de caractères est: rw-rw-rw-.
Il y a donc 9 bits et 9 caractères d'un côté et de l'autre. Chaque bit posé (1) du nombre octal fixe le caractère analogue du même emplacement sur -, dans la mesure ou y figurait auparavant r, w ou bien x.
Le modèle de bits 000111111 a donc pour effet que pour un droit rw-rw-rw-, les six derniers caractères sont fixés sur -, de sorte que l'on obtient rw------- (ce qui correspond en octal à 0600).
|
|
Efface un ou plusieurs fichiers en même temps. Les répertoires ne peuvent pas être effacés avec cette commande, la fonction rmdir étant faite pour ça.
Attend comme paramètre:
1. une liste de fichiers qui doivent être effacés.
Renvoie le nombre de fichiers effacés avec succès.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
chdir("/tmp");
opendir(DIR,".");
my @elements = readdir(DIR);
closedir(DIR);
my $nombre = 0;
foreach (@elements) {
unless( -d $_) {
$nombre+= unlink($_);
}
}
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "$nombre de fichiers retirés!\n";
print "</body></html>\n";
|
Le script en exemple passe dans le répertoire où quelque chose doit être effacé avec chdir . Ensuite le répertoire est lu avec opendir, readdir et closedir. Les éléments du répertoire figurent ensuite dans la liste @elements. Dans une boucle foreach la liste est ensuite traitée. Il est demandé avec unless( -d $_) si l'élément actuel n'est pas un répertoire. Si ce n'est pas le cas, l'élément, donc un fichier est effacé avec unlink. Quand l'effacement est couronné de succès, la variable $nombre est incrémentée de 1. À la fin, le script sort du code HTML au navigateur appelant en faisant part du nombre de fichiers effacés.
|
|
Modifie la date et l'heure du dernier accès en lecture et du dernier accès en écriture d'un ou de plusieurs fichiers.
Attend comme paramètre:
1. une mention de temps pour le dernier accès en lecture. Il doit s'agir d'une mention en secondes depuis le 1/1/1970 telle qu'elle est renvoyée par exemple, par la fonction time.
2. une mention de temps pour le dernier accès en écriture. Il doit s'agir d'une mention en secondes depuis le 1/1/1970.
3. une liste de fichiers dont la date et l'heure doivent être changés.
Renvoie le nombre de fichiers "affectés" par la modification.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $fichier = $ENV{'QUERY_STRING'};
my $maintenant = time();
utime($maintenant,$maintenant,$fichier);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "La date et l'heure de $fichier ont été actualisées!\n";
print "</body></html>\n";
|
Le script actualise la date et l'heure d'un fichier. À l'appel, il attend la transmission d'un paramètre qui est noté dans l'URI derrière un point d'interrogation. Le paramètre transmis comprend la mention de chemin d'un fichier dont la date et l'heure doivent être actualisées. Exemple:
http://localhost/cgi-bin/test.pl?/mydocs/textes/important.txt. Le paramètre transmis est sauvegardé par le script dans la scalaire $fichier. Pour rechercher la date et l'heure actuelles, la fonction time est appelée. Elle donne le nombre de secondes écoulées depuis le 1/1/1970, donc exactement la forme attendue par utime. La valeur renvoyée est sauvegardée dans $maintenant. Maintenant le script peut appeler la fonction utime et lui transmettre les paramètres souhaités. Quand vous désirez traiter plus d'un fichier en une seule fois, mentionnez tous les fichiers désirés séparés par des virgules.
Enfin, le script envoie du code HTML au navigateur qui confirme la modification du fichier.
Tous les systèmes d'exploitation ne distinguent pas comme Unix deux dates et heures différentes: Sous Windows par exemple il n'y a pas de date et heure pour le dernier accès en lecture mais seulement pour le dernier accès en écriture. Transmettez néanmoins toujours les deux paramètres à utime. Sous Windows seules la date et l'heure existantes seront alors modifiées.
|
| |
 |
Fonctions pour les appels du système d'exploitation
|
 |
Fonctions pour l'entrée et la sortie et la lecture et l'écriture de données
|
| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org