1  Quelques commandes Unix

Il est proposé de réimplanter quelques commandes Unix courantes. Ces quelques exercices illustrent l’utilisation des primitives POSIX relatives au système de fichiers : autorisations d’accès, parcours d’un répertoire, parcours d’un système de fichiers, entrées/sorties.

Vérifier les droits d’accès... et expliquer

La commande Unix access vérifie les droits d’accès (lecture : option -r, écriture : option -w, exécution : option -x) à un fichier donné. L’invocation de la commande comporte une option obligatoire spécifiant le ou les accès à vérifier. (Cette commande est malheureusement en voie de disparition...)

La commande access n’affiche rien mais retourne son résultat sous la forme d’une terminaison sur un succès ou un échec. Ce comportement peut par exemple être mis en valeur dans une session telle la suivante (Il s’agit d’une session C-shell. Pour un shell de la famille de sh tel bash, on utilisera $? en remplacement de $status) :

% access -r /tmp
% echo $status 
0
% access -r /tmp && echo OK
OK
% access -w /etc/passwd
% echo $status 
1
% access -w /etc/passwd && echo OK
% 

Dans le cadre de ces exercices, il s’agit de fournir notre propre version de la commande access qui supporte l’option supplémentaire -v (verbose) expliquant, en cas d’échec, ce pourquoi l’accès est impossible. Les raisons possibles de l’échec sont les suivantes :

1. Le droit d’accès demandé au fichier n’est pas positionné.
2. Le fichier n’existe pas.
3. Une des composantes du nom de fichier n’est pas un répertoire.
4. Une des composantes du nom du fichier est trop longue.
5. Le nom du fichier est trop long.
6. Le nom du fichier comporte trop de liens symboliques.
7. Autre erreur.

Contraintes POSIX

La norme POSIX fournit un certain nombres de contraintes de taille ou longueur diverses. Ces contraintes définissent des valeurs minimales que doit garantir toute implémentation de la norme. La norme POSIX impose aussi que les valeurs effectivement garanties par l’implémentation soient accessibles aux applications.

Parmi les macro-définitions fournies par les fichiers <limits.h> et <unistd.h> on trouve

NAME_MAX

qui est la longueur maximale d’un nom d’entrée dans le système de fichiers (dont la valeur minimale requise est 14) ;

PATH_MAX

qui est la longueur maximale d’un chemin dans le système de fichiers (dont la valeur minimale requise est 255).

Code source POSIX

Afin de spécifier au compilateur que le code source C que l’on désire compiler est conforme à la norme POSIX, on définira la macro _XOPEN_SOURCE avec une valeur supérieure ou égale à 500.

Un Makefile comportera donc par exemple :

CC      = gcc                              
CFLAGS  = -Wall -Werror -ansi -pedantic    
CFLAGS += -D_XOPEN_SOURCE=500              
CFLAGS += -g

Les curieux pourront consulter le contenu du fichier /usr/include/features.h !

Copie d’une session

La commande script permet de fournir dans un fichier une copie d’une session shell. Exemple :

% pwd
/users/phm/ens/pds/src
% ls
CVS/     atexit.c  echouser.c  mecho*         mecho.c~    mprintenv.c~
Makefile atexit.c~ maccess*    mecho.c        mprintenv*
atexit*  echouser* maccess.c   mecho.c.~1.1.  mprintenv.c
% script session.txt
Script started, output file is session.txt
% pwd
/users/phm/ens/pds/src
% ls
CVS/     atexit.c  echouser.c  mecho*         mecho.c~    mprintenv.c~
Makefile atexit.c~ maccess     mecho.c        mprintenv*  session.txt
atexit*  echouser* maccess.c   mecho.c.~1.1.~ mprintenv.c
% exit
Script done, output file is session.txt
% ls
CVS/     atexit.c  echouser.c  mecho*         mecho.c~    mprintenv.c~
Makefile atexit.c~ maccess     mecho.c        mprintenv*  session.txt
atexit*  echouser* maccess.c   mecho.c.~1.1.~ mprintenv.c
% cat session.txt
Script started on Sun Dec 19 05:52:24 2004
% pwd
/users/phm/ens/pds/src
% ls
CVS/     atexit.c  echouser.c  mecho*         mecho.c~    mprintenv.c~
Makefile atexit.c~ maccess     mecho.c        mprintenv*  session.txt
atexit*  echouser* maccess.c   mecho.c.~1.1.~ mprintenv.c
% exit
Script done on Sun Dec 19 05:52:30 2004
%  

Retrouver une commande

La commande Unix which recherche les commandes dans les chemins de recherche de l’utilisateur.

La variable d’environnement $PATH contient une liste de répertoires séparés par des « : ». Lors de l’invocation d’une commande depuis le shell, un fichier exécutable du nom de la commande est recherchée dans l’ordre dans ces répertoires. C’est ce fichier qui est invoqué pour l’exécution de la commande. Si aucun fichier ne peut être trouvé, le shell le signale par un message.

La commande which affiche le chemin du fichier qui serait trouvé par le shell lors de l’invocation de la commande :

% echo $PATH 
/bin:/usr/local/bin:/usr/X11R6/bin:/users/phm/bin
% which ls 
/bin/ls
% echo $status
0
% which foo 
foo: Command not found.
% echo $status
1

Afficher le répertoire courant

La commande pwd (print working directory) affiche le chemin absolu du répertoire de travail courant.

La fonction

char *getcwd(char *buf, size_t size);

de la bibliothèque C copie le chemin absolu du répertoire courant dans le tableau buf de taille size. Si buf est NULL, la bibliothèque alloue dynamiquement un espace nécessaire pour y stocker le résultat et en retourne alors l’adresse.

L’implantation de cette fonction getcwd() ne repose pas sur un appel système unique mais exploite la structuration des répertoires et les liens . et .. pour construire ce chemin absolu.

Pour un processus donné, le système ne conserve que le numéro d’inœud courant, à partir duquel il lui est possible d’accéder au répertoire courant. La navigation à partir de ce répertoire est utilisé pour tous les chemins relatifs, en particulier ceux vers des répertoires parents, tels .. ou ../.., etc.

Le système conserve aussi l’inœud du répertoire racine / qui lui permet d’accéder à tous les chemins absolus.

Il s’agit maintenant de proposer une implantation de la commande pwd ne reposant pas sur la bibliothèque C. Le principe en est le suivant :

• on part du répertoire . ;
• on cherche dans le répertoire .. le nom du lien qui référence le même inœud que . ; ce nom existe assurément ; soit cname ce nom ; le chemin absolu que l’on cherche à construire est de la forme /.../cname ;
• on cherche alors dans le répertoire ../.. le nom du lien qui référence le même inœud que .. ; soit pname ce nom ; le chemin absolu que l’on cherche à construire est de la forme /.../pname/cname ;
• on itère cette remontée jusqu’à trouver la racine du système de fichiers ;
• la racine du système de fichier peut être identifiée :
  • par le fait qu’elle correspond à l’inœud du chemin /, ou
  • par le fait qu’elle est son propre parent.

Informations sur une entrée

Deux valeurs peuvent être utilisées pour rechercher des informations sur une entrée dans un système de fichiers :

• des valeurs de type struct dirent retournée par l’appel système readdir() ;
• des valeurs de type struct stat retournée par l’appel système stat(), lstat() (dans le cas d’un lien symbolique, informations sur le fichier lui-même et non sur le fichier désigné par le lien symbolique), ou fstat() (informations sur un fichier désigné par un descripteur).

Ces structures comportent les champs suivants :

struct dirent { 
    ino_t     d_ino;      /* File number of entry */ 
    char      d_name[];   /* Name of entry */

struct stat {
    dev_t     st_dev;     /* Device ID of device containing file */
    ino_t     st_ino;     /* File serial number */
    mode_t    st_mode;    /* Mode of file */
    nlink_t   st_nlink;   /* Number of hard links to the file */
    uid_t     st_uid;     /* User ID of file */ 
    gid_t     st_gid;     /* Group ID of file */
    dev_t     st_rdev;    /* Device ID (if file is character or block
                             special) */
    off_t     st_size;    /* For regular files, the file size in bytes.
                             For symbolic links, the length in bytes of
                             the pathname contained in the symbolic 
                             link */
    time_t    st_atime;   /* Time of last access */
    time_t    st_mtime;   /* Time of last data modification */
    time_t    st_ctime    /* Time of last status change */
    blksize_t st_blksize; /* A file system-specific preferred I/O block 
                             size for this file */
    blkcnt_t  st_blocks;  /* Number of blocks allocated for this file */

Notez qu’il s’agit là des champs définis par la norme POSIX, une implantation particulière peut fournir des informations supplémentaires que l’on évitera d’utiliser.

Les macros suivantes peuvent être utilisées sur le champ st_mode :

S_ISREG(m)

Test for a regular file.

S_ISDIR(m)

Test for a directory.

S_ISLNK(m)

Test for a symbolic link.

S_ISFIFO(m)

Test for a pipe or FIFO special file.

S_ISSOCK(m)

Test for a socket.

S_ISBLK(m)

Test for a block special file.

S_ISCHR(m)

Test for a character special file.

Parcours d’une hiérarchie

La commande du (disk usage) rapporte la taille disque utilisée par un répertoire et l’ensemble de ses fichiers (y compris ses sous-répertoires).

Deux tailles peuvent être prises en compte pour un fichier :

• la taille apparente, qui est le nombre d’octets contenus dans le fichier ;
• la taille réelle, qui correspond effectivement au nombre de blocs disque utilisés par le fichier.

Les champs st_size et st_blocks d’une structure de type struct stat retournée par l’appel système stat() contiennent respectivement la taille apparente et la taille réelle d’un fichier ; se référer à l’encart.

Comme pour toutes les commandes réalisant un parcours d’une hiérarchie, il faut préciser le traitement réalisé sur les liens rencontrés : doivent-ils être suivis ou non ?

La commande du comporte donc deux options

-L

indiquant de suivre les liens symboliques ; ce qui n’est pas le cas par défaut ;

-b

indiquant de rapporter les tailles apparentes ; ce sont les tailles réelles qui sont rapportées sinon.

Une possible implantation peut définir deux variables globales pour mémoriser l’état de ces options :

static int opt_follow_links = 0; 
static int opt_apparent_size = 0; 

Dans un premier temps on suppose que l’option opt_follow_links est définie à faux.

Afficher la fin d’un fichier

La commande Unix tail affiche les dernières lignes des fichiers désignés par les paramètres de la ligne de commande. L’option -n indique d’afficher les n dernières lignes. Par défaut, les 10 dernières lignes sont produites.

Une solution plus efficace consiste à lire le fichier depuis la fin. On lit un tampon de caractères d’une taille arbitraire (mais judicieusement choisie !). On y compte le nombre de retours à la ligne. S’il est supérieur à n, on peut afficher les n dernières lignes. Sinon, on lit le tampon précédent...