Unix

Gestion des répertoires

Attributs des répertoires et des fichiers

ls

Un utilisateur est identifié sous Unix pour un nom et un numéro d'utilisateur, ainsi que par son appartenance à un ou plusieurs groupes. Les fichiers Unix disposent donc de droits d'acces à ces deux niveau. Les droits se décomposent classiquement en droits de lecture (r), écriture (w) et exécution (x) et sont définis respectivement pour l'utilisateur, pour les membres du groupe et pour les autres utilisateurs (chaine rwxr-xr-x dans le listing).

Les droits sur répertoires ont des significations particulieres, indiquant la possibilite de lire le contenu d'un répertoire (r), de créer de nouveaux fichiers dans un répertoire (w), et la possibilité de faire un cd dans ce répertoire (x).

On change les droits des fichiers avec la commande chmod qui a la syntaxe suivante: chmod [ugoa][+-=][rwx] files....

% cd /
% ls -l
total 108
drwxr-xr-x   2 root     root         4096 Oct 24 16:02 bin/
drwxr-xr-x   2 root     root         4096 Oct 24 17:02 boot/
drwxr-xr-x   6 root     root        36864 Oct 26 15:26 dev/
drwxr-xr-x  41 root     root         4096 Oct 26 22:30 etc/
-rw-r--r--   1 root     root            2 Sep 24 23:53 fonts.dir
drwxr-xr-x   6 root     root         4096 Feb  6  1996 home/
drwxr-xr-x   4 root     root         4096 Oct 24 16:00 lib/
drwxr-xr-x   2 root     root        16384 Sep 24 23:27 lost+found/
drwxr-xr-x   2 root     root         4096 Sep 20 17:13 misc/
drwxr-xr-x   4 root     root         4096 Oct  9  1998 mnt/
drwxr-xr-x   2 root     root         4096 Aug 23 18:03 opt/
dr-xr-xr-x  70 root     root            0 Oct 26 15:25 proc/
drwxr-x---   9 root     root         4096 Oct 27 11:06 root/
drwxr-xr-x   3 root     root         4096 Oct 24 17:17 sbin/
drwxrwxrwt  13 root     root         4096 Oct 27 14:45 tmp/
drwxr-xr-x  21 root     root         4096 Aug  2  1998 usr/
drwxr-xr-x  21 root     root         4096 Oct 24 16:02 var/
      

Les manipulations possibles de fichiers sont:

Les variables

Les variables ne sont pas typées.

% set X=123
% set Y=toto
% echo $X $Y
123 toto
      

Les variables peuvent être visibles uniquement dans le shell courant (set) ou bien dans tous les processus fils (setenv). setenv sert pour affecter les variables d'environnement, par exemple DISPLAY.

% set V1=1
% setenv V2 2
% csh
% echo $V1
V1: Undefined variable.
% echo $V2
2
% exit
% echo $V1 $V2
1 2
      

Les structures de controle

Les boucles, les itérations, les tests sont au rendez-vous:

% foreach i ( 1 2 3 4 )
? echo $i
? end
1
2
3
4

% foreach file ( * )
? echo $file
? end
fichier.c
fichier.o
Makefile

% if ( $i < 4 ) then
?    echo oui
? else
?    echo non
? fi
oui

% while ( $condition )
? instruction
? instruction
? end
      

Substitution de variables

% set variable = 123
% echo $variable
123
% set v2 = un nom avec un espace
% echo $v2
un
% set v2 = "variable vaut $variable"
% echo $v2
variable vaut 123
% set v2 = 'variable vaut $variable'
% echo $v2
variable vaut $variable
% set v2 = variables\ vaut\ $variable
% echo $v2
variable vaut 123
% set d  = "la date est `date`"
% echo $d
la date est Wed Oct 27 17:16:05 MET DST 1999
      

Les simples quotes interdisent l'évaluation du contenu à la différence des doubles quotes.

L'anti-slash \ interdit l'interprétation du caractère qui le suit.

% set v2 = xxxx\'yyyy
% echo $v2
% xxxx'yyyy
      

Il est possible de compléter des noms de fichiers.

% set v2 = fichier.*
% echo $v2
fichier.c fichier.o
      

Les flots standards d'entrée/sortie

Tout processus Unix lit les données en entrée sur un fichier stdin, écrit les données en sortie sur un fichier stdout, et écrit les messages d'erreur sur un troisième fichier stderr. Clavier et écran ne sont, pour le système Unix, que des fichiers particuliers, en lecture seule pour le premier et en écriture seule pour le deuxième. Ces trois flots sont représentés en csh par les symboles suivants:

On connecte les flux d'entrée/sorties de deux processus avec un “pipe” Unix:

% cat development.sgml | wc
    571    3147   25034
% make |& more
      

On utilise un sous-shell pour séparer stdin et stdout:

% ( make > make.log ) >& make.err
      

Intérêt des sous-shells

L'utilisation des back-quotes permet de laner des commandes dans des sous-shells et de substituer la commande par son résultat dans le shell courant.

% foreach f (`cat file_list`)
? rm -f $file
? end
      

Substitutions des noms de fichiers

Il existe un certain nombre de regles de substitution, qui, même si une certaine ressemblance existe, ne s'apparentent pas à des expression régulières.

• *: plusieurs caractères différents de ".".

• ?: un seul caractère different de ".".

• [abc]: une alternative de caractères.

• {chaine1,chaine2}: une alternative de chaines de caractères.

Exemples:

• *.*: tous les fichiers contenant un point.

• .??*: tous les fichiers commencant par un point et avec au moins deux autres caractères. Cela permet de lister les fichiers cachés (commencant par .) et d'exclure . et .. (le répertoire courant et le répertoire parent respectivement).

• ~/src/[12]/Makefile: permet de matcher les deux fichiers /home/bellet/src/1/Makefile et /home/bellet/src/1/Makefile. En effet, le symbole ~ est un raccourci pour la variable d'environnement HOME, indiquant le home-directory de l'utilisateur.

• *.[hc]: permet de matcher tous les fichiers .c et .h du répertoire courant.

La galere des expressions numériques

Il faut utiliser la commande externe expr.

% set a = 3
% set b = `expr \( 1 + 3 \) \* $a`
% echo $b
12
      

Faire un compteur est possible:

% set a = 0
% while ( $a < 10 )
?   echo Traitement du fichier numéro $a
?   set a = `expr $a + 1`
? end
      

Les conditions

L'écriture des conditions est tres similaire à la syntaxe du langage C. Encore une chance, ce shell a été écrit pour ca!

% if ( $x == "chaine" ) ...
% if ( $x <= 10 && $y == 2 ) ...
% if ( $x != 1 || "$2" == `hostname` ) ...
% if ( -r fichier1 && -x fichier2 && -d fichier3 ) ...
      

Un autre moyen d'écrire des tests conditionnels consiste à utiliser une caractéristique des processus Unix, qui retournent un entier lorsqu'ils se terminent indiquant si la commande s'est bien exécutée ou pas. Si la commande s'est bien terminée, la variable d'environnement $status vaut 0, sinon tout autre valeur correspond à un code d'erreur. Voir les pages de manuel de chaque commande Unix pour connaitre la signification des codes d'erreur retournés. Cet entier est la valeur renvoyée par les programmes en C écrit scrupuleusement:

int main() {
        ... plein de choses;
        procedure_truc();
        ... encore plein d'autres choses;
        /* 
         * fin normale du programme
         */
        return 0;
}
void procedure_truc () {
        ...
        if (erreur) {
           fprintf (stderr,"erreur irrecuperable. bye.\n");
           /*
            * fin anormale
            */
           exit (1);
        }
}
     

Ainsi, les primitives de comparaison && et || utilisent la valeur de $status pour fonctionner. On peut écrire des conditions également et de façon très compactes ainsi:

% echo azerty | grep -q aze && echo found
found
% echo azerty | grep -q qwe && echo found
% echo azerty | grep -q qwe || echo not found
not found
      

Gestions de flot d'entrées/sortie et grep

La commande grep lit des données depuis un fichier ou depuis l'entrée standard, et affiche sur sa sortie standard les lignes contenant la chaine de caractères passée en paramètre sur la ligne de commande.

Les instructions grep et egrep permettent de faire des recherches d'expression régulières dans le flux stdin. Par exemple on peut effectuer une recherche de deux chaines de caractères dans un fichier en utilisant une expression régulière dans la commande egrep. On notera qu'il est nécessaire de mettre l'expression régulière entre quotes, afin que le | ne soit pas interprété comme le pipe Unix dans cet exemple:

% egrep 'NNTPSERVER|PATH' ~/.cshrc 
setenv  NNTPSERVER      demo2.univ-lyon1.fr
setenv  LD_LIBRARY_PATH ${HOME}/creatis/lib:/usr/local/lib
setenv  CLASSPATH       /usr/lib/netscape/java/classes/java40.jar
      

On peut faire un ET avec un pipe Unix cette fois-ci. Dans cet exemple, on va matcher par exemple la ligne qui contient les deux chaines passées a chacun des grep:

% grep define *.[hc] | grep MA_CONSTANTE
fichier.c:#define MA_CONSTANTE 10        /* Ma constante */
      

L'option -i est très utile pour ne pas différencier majuscules et minuscules dans la recherche.

A savoir sur les expressions régulières:

La commande find

La commande find permet de rechercher des fichiers selon certains critères. Sa syntaxe est : find [chemin] [exp1] [exp2] ... , où chemin est le répertoire de départ de la recherche. Les principales expressions utiles sont:

• -name "filename": des substitutions sont possibles.

• -print ou -ls: affiche les fichiers trouvés.

• -type f ou -type d: matche les fichiers ou les répertoires.

• -exec execute une commande sur chaque fichier matché.

Exemple d'utilisation, les trois dernières commandes sont équivalentes:

% find ~ -name "*.o" -print

% find -name core -exec rm -f {} \;
% /bin/rm -f `find -name core -print`
% find -name core -print | xargs rm -f
      

sed, stream editor

C'est une commande très complexe. Elle est intéressante pour substituer des expressions entre le stdin et le stdout. Exemple:

% sed '30,50s/nom1/nom2/g' < fichier.c > fichier.new
      

30,50 indique les numéros de lignes du flot d'entrée concernés par la substitution. g autorise plusieurs substitutions sur la même ligne. Un détail important dans l'écriture des expressions régulières est que la substitution concernera toujours la chaîne la plus longue possible.

L'intérêt de sed est qu'il est utilisable sous l'éditeur vi, en mode commande, accessible par Escape. Il peut aussi servir d'excellent outils de filtre.

awk

awk, à la différence de sed est un véritable langage de traitement de flot, et pas seulement un filtre d'expressions régulières. Quelques exemples d'utilisation:

Pour récupérer la troisième colonne d'un tableau de résultats:

% cat fichier | awk '{print $3}'
      

print peut etre remplacé par un printf pour une meilleure mise en forme, avec les mêmes arguments qu'en langage C.

Pour faire la somme des valeurs d'une colonne:

% awk 'BEGIN{n=0}{n+=$3}END{print n}' < fichier
      

Il existe une abondante documentation sur le sujet.

Le séparateur de champs est l'espace par défaut. Il est paramétrable.

Quelques fonctions largement utilisées dans les shells

basename retourne le nom d'un fichier en lui otant les répertoire qui précedent son nom et éventuellement l'extension de son nom de fichier.

% basename /a/b/c/d.txt .txt
d
      

Une application peut etre de changer toutes les extensions des fichiers d'un repertoire:

foreach file ( *.c )
?  mv $file `basefile $file .c`.old
?  end
      

On peut faire la meme chose avec un sed.