Ivan"> Kurzweg Ivan Kurzweg , Pascal Picard 2002 - 2006 Permission to use, copy, modify, and distribute this documentation for any purpose with or without fee is here by granted, provided that the above copyright notice and this permission notice appear in all copies. Ce cours est largement inspiré du cours de Pascal Picard disponible sur https://seth.homeunix.net/corto interprète de commande, shell, csh, tcsh, completion, historique Le &shell; est d'abord l'interpréteur de commande d'un système &unix; mais c'est aussi un quasi langage de programmation interpreté autorisant la récursivité. Historiquement le premier &shell; du système &unix; est le Bourne-Shell (sh). Ce &shell; n'a cessé d'être amélioré et l'université de Berkeley qui a beaucoup contribué à la branche BSD d'&unix; a développé le C-Shell (&fshell;), un successeur de sh munit de fonctionnalités étendues par rapport à son ancêtre. Le C-Shell à son tour possède un successeur : TC-Shell (tcsh), ce dernier étend les fonctionnalités de son prédécesseur et apporte davantage de convivialité. Ces caractéristiques en font un équivalent au GNU Bourne-Again-Shell (GNU/bash). Ces shells syntaxiquement orientés C restent les shells par défaut des flavors BSD et c'est pourquoi nous nous proposons, dans ce support, de les présenter principalement dans un contexte d'interactivité où ils sont plutôt efficaces. Voici néanmoins un résumé des différentes familles de Shells : sh ("Bourne shell", Steve Bourne) : shell historique (disponible sur tous les Unix) csh ("C-shell", Bill Joy) : shell BSD (disponible sur tous les Unix) ksh ("Korn shell") : shell normalisé POSIX (P1003.2) et ISO (HP, Solaris) bash ("Bourne again shell" de Brian Fox et Chet Ramey) : Ksh du domaine public (installé sur toutes les machines Linux) zsh ("Zero shell") : Ksh du domaine public (installé sur toutes les machines) tcsh ("Toronto C-shell") rc (Plan9, Tom Duff) Le &shell; est un interpréteur de commande en ligne. Chaque entrée sur un terminal est analysée et décomposée en terme d'instructions à exécuter. Ces instructions peuvent impliquer des commandes internes que le &shell; connaît et est en mesure d'exécuter directement, ou bien d'autres commandes déclenchant des programmes que le &shell; va tenter de localiser et de lancer. Le &shell; dispose d'instructions (structures de contrôle, ...) et de variables qui le rende en partie comparable à un langage de programmation, de sorte que l'on peut écrire des shell scripts, littérallement de petits ou moyens programmes rédigé en &shell;. Un interpréteur &shell; exécutent trois types de commandes : Les commandes internes [built-in commands], comme par exemple : cd, pwd, umask ... ou bien encore les éléments algorithmiques tels if .. then .. else .. endif, foreach ... ... Les commandes externes indépendantes du &shell; et localisées dans les répertoires, comme par exemple : ls (/bin/ls), find (/usr/bin/find) ... Ces commandes nécessitent la création d'un nouveau &shell; pour leur exécution contrairement à celles relevant de la première catégorie. Les commandes définies par un alias. Le &shell; est le premier processus d'une session, son choix est indiqué dans le fichier /etc/passwd. IL est attaché au terminal console (login), ou à un pseudo-terminal (remote login, activation d'une fenêtre). Le &shell; ouvre initialement trois fichiers standards : l'entrée standard (stdin, fd=0), par défaut le clavier la sortie standard (stdout, fd=1), par défaut l'écran lasortie erreur standard (stderr, fd=2), par défaut l'écran Le &shell; lit sur son entrée standard la commande jusqu'à la fin de ligne (\n) et interprète les métacaractères et les opérateurs les lignes de commandes jusqu'à la fin de fichier (^D) dans le cas d'un script Au lancement d'une commande, le &shell; recherche l'éxécutable de la commande à l'aide du PATH dans le cas d'une commande externe exécute en premier plan dans un processus fils la commande et en attend le résultat exécute en arrière plan dans un processus fils la commande, sans en attendre le résultat (non bloquant) il possède un mécanisme d'historisation et de rappel (et d'éditions des commandes &fshell2;) ; il permet le contrôle des processus (suspension), reprise asynchrone (background) ou interactive (foreground)) ; il permet de traiter les tableaux de caractères ; il possède des directives de programmation proche du C ; il possède un mécanisme de completion ; il permet le calcul arithmétique. Lors du login, &fshell; exécute les instructions contenues dans le fichier /etc/csh.cshrc puis celles du fichier /etc/csh.login puis celles de ~/.cshrc (tcsh lit le script ~/.tcshrc, s'il existe et sinon ~/.cshrc) et enfin celles de ~/.login. La signification du caractère ~ est donnée en . Lors de la fin de session (logout) &fshell; ou tcsh exécutent les commandes des fichiers /etc/csh.logout et ~/.logout, dans cet ordre. Un sous-&shell;, ne lit pas les fichiers suffixés en .login à son démarrage ni les fichiers suffixés en .logout à sa terminaison. Il lit par contre les fichiers~/.cshrc ou ~/.tcshrc. Un sous-shell est un shell lancé depuis un autre shell, en appelant directement son exécutable. De ce qui précède, on déduit que les commandes à exécuter une seule fois pendant une session sont à placer dans les fichiers suffixés en .login (typiquement les variables d'environnement), tandis que les autres sont à placer dans les fichiers suffixés en .cshrc. Le fichier ~/.cshrc contient typiquement : la définition des alias ; la définition des paramètres de fonctionnement ; l'initialisation des variables. ' set prompt2='%B%n%b:>> ' set path = (/usr/local/sbin /usr/local/bin /sbin /bin /usr/sbin \ /usr/bin /usr/X11R6/bin $HOME/bin) set correct = cmd /usr/X11R6/bin/xrdb -load ~/.Xdefaults >& /dev/null if ($?prompt) then # An interactive shell -- set some stuff up set filec set history = 2048 set savehist = 2048 set histfile = ~/.history set mail = (/var/mail/$USER) set notify set addsuffix set autolist set machbeep = nomatch set cdpath = ( ~ ~/bin ) set symlinks = ignore if ( $?tcsh ) then set echo_style = both set histdup = all set savehist = ( 2000 merge ) bindkey "^W" backward-delete-word bindkey -k up history-search-backward bindkey -k down history-search-forward source ~/.tcsh_comp endif endif ]]> Le fichier ~/.login contient essentiellement la définition des variables d'environnement. Le fichier ~/.logout contient essentiellement des commandes de suppression de fichiers inutiles. /dev/null \) echo "... done" echo "last connexion at [`date +%Y-%M-%d` a `date +%H:%I:%S`] pour [`logname`] s ur [`tty`]" > ~/.deconnex ]]> Quel est le rôle de la commande find dans le contexte du listing précédent (~/.logout) ? Il est possible à tout moment et notamment après une modification de réexécuter les fichiers au moyen de la commande source. $ > source ~/.login $ > source ~/.cshrc Dans les distributions xBSD on peut voir les deux fichiers suivants : /.login et /.profile (situés à la racine). Ils sont exécutés uniquement dans le mode mono-utilisateur [single-user mode]. Leurs modifications sont à faire avec le plus grand soin. On parle de variables d'environnement car elles sont automatiquement transmises à tous les processus fils du &shell;, &ie; tous les processus lancés par ce &shell;. Les variables qui suivent ont un sens particulier pour le &shell; (&fshell; et &fshell2;), elles sont utilisées par certaines commandes du &shell; ou du système. Parmi elles, argv, cwd, home, path, prompt, shell et status sont toujours définies par le &shell;. Si l'on exclut les variables cwd et status, leur positionnement intervient seulement à l'initialisation. Ces variables ne sont plus modifiées, sauf éventuellement par l'utilisateur. Variable d'environnement Sémantique argv Arguments du &shell;, résultant de la substitution des paramètres positionnels. $argv[1] correspond à $1, $argv[2] à $2 ... autologout [&fshell2;] Positionné à un certain nombre de minutes, permet de déconnecter automatiquement l'utilisateur au bout de cette période d'inactivité. cdpath Liste de répertoires alternatifs dans lesquels sera effectuée la recherche des sous-répertoires lors de l'utilisation de la commande cd avec un argument de type nom relatif. correct [&fshell2;] Positionnable à all ou cmd. Dans le deuxième cas, permet la correction des erreurs de typos sur les noms de commandes. cwd Chemin absolu du répertoire courant. echo filec Permet la completion des noms de fichiers. histchars Chaîne de caractères à utiliser dans les substitutions de l'historique. Les éléments de cette chaîne remplacent les caractères standards, ainsi le premier caractère de cette chaîne remplace le '!', le second remplace le '^' ... histfile Chemin d'accès au fichier d'historique. history Permet de contrôler le nombre de lignes de l'historique. Noter que la dernière commande exécutée est toujours sauvegardée dans l'historique. home Désigne le répertoire de localisation de celui qui invoque la commande. L'expansion de nom de fichier ~ se réfère à cette variable. ignoreeof Le positionnement de cette variable permet au &shell; d'ignorer le caractère de fin de fichier quand il est généré depuis un terminal. Cela permet donc d'immuniser le &shell; d'une fin accidentelle déclenchée par la séquence ^D (lire <CTRL>-D). inputmode [&fshell2;] Définit le mode en insertion (par défaut) ou en overwrite pour l'édition de la ligne de commande . mail Indique le fichier dans lequel le &shell; contrôle l'arrivée de nouveaux messages. Si la première valeur spécifiée dans mail est numérique, elle surcharge l'intervalle de temps entre chaque vérification, fixé par défaut à 10 minutes. Si la variable spécifie différents fichiers, chacun d'eux sera scruté pour détecter l'arrivée de nouveaux messages. noclobber Modifie la sémantique des commandes de redirections > et >> permettant ainsi d'éviter un effacement accidentel. L'utilisation de > renvoit une erreur si le fichier existe. Quand à >>, elle se réfère uniquement aux fichiers existants. noglob Si cette variable est positionnée, elle inhibe la fonctionnalité d'expansion des noms de fichiers. Surtout utile dans les scripts &shell;. nonomatch Si cette variable est positionnée, il n'y a pas d'erreurs lorsque le mécanisme d'expansion des noms de fichiers ne correspond pas à tous les fichiers existants. Dans ce cas le motif est retourné. notify Si positionné alors permet au &shell; de notifier de manière asynchrone la completion des jobs. Le comportement par défaut spécifie de présenter la completion des jobs avant d'imprimer le prompt. path Définit l'ensemble des chemins dans lesquels le &shell; recherche les commandes externes à exécuter. prompt Définit l'invite de commandes en mode interactif. rmstar [&fshell2;] Si positionné, permet de demander à l'utilisateur confirmation lorsqu'il tape la commande rm *. savehist Si l'argument est numérique, spécifie le nombre de lignes sauvegardées dans ~/.history, quand l'utilisateur se déloggue. shell Fichier dans lequel réside le &shell;. shlvl [&fshell2;] Nombre de &shell; empilés, remis à 1 par un &shell; de login. status Statut retourné par la dernière commande exécutée. time Si cette variable est positionnée (valeur en secondes), alors toute commande dont la durée d'exécution dépasse cette valeur est suivie à sa terminaison de l'affichage de statistiques sur les temps utilisateur, système et réel consommés ainsi que le ratio temps utilisateur et temps système sur temps réel consommé. verbose En &fshell; comme en &fshell2; certaines variables du &shell; et des variables d'environnement sont maintenues à des valeurs identiques par le &shell;. Ce sont les variables user et USER, group et GROUP, home et HOME, term et TERM, path et PATH, et enfin shlvl et SHLVL. Les métacaractères jouent le rôle de classe de représentation des fichiers dans le contexte du répertoire courant si rien n'est précisé ou bien dans celui du répertoire explicitement nommé. Le caractère ~ placé en première position désigne le répertoire personnel de l'utilisateur courant : Le caractère * est substituable par n'importe quelle combinaison de 0 ou plusieurs caractères. Exemple : Lister l'ensemble des fichiers possédant le suffixe .sh du répertoire courant : Exemple : Lister les fichiers (non cachés) du répertoires courant : $echo * cmd.sh fcomp.sh fcomp.sh.2 fdate.sh ftestparm.sh ftestvect.sh ftestvect.sh.2 shells.pdf shells.xml Les fichiers commençant par le caractère . ou fichiers cachés d'&unix; [dot files] ne peuvent être remplacés par aucun caractère, &ie; le caractère * est inopérant. Le caractère ? est substituable par un unique caractère quelconque. Exemple : Lister les fichiers commençant par le motif ft et dont le suffixe est de trois caractères : Les caractères [] permettent une substitution par un caractère parmi l'ensemble dénoté par les crochets. Exemple : Lister les fichiers cachés du répertoire $HOME de l'utilisateur courant, dont le second caractère est compris entre 'a' et 'e' (le premier étant le .) : Autre exemple, utilisation de la négation (extension tcsh) marqué par le caractère ^ : Lister les fichiers cachés du répertoire $HOME de l'utilisateur courant, dont le second caractère n'est ni '.', ni 'a', ni 'b', ni 'c', ni 'd' ni 'e' (le premier étant un '.') : Les caractères { } permettent la substitution par un mot de l'énumération dénotée par les accolades. Exemple : Lister les fichiers se terminant par les suffixes .xml et .pdf et .fo : Quelques autres caractères spéciaux Caractère Sémantique ; Séparateur de commande, &ie; opérateur de séquentialité. & Séparateur de commande qui place la commande qui le précède en arrière-plan, &ie; en exécution asynchrone. \ Quote le caractère qui le suit et notamment pour les caractères spéciaux, inhibe leur sémantique particulière. $ Accède au contenu de la variable. ' [quote] Quote le texte qui le suit jusqu'au ' fermant. ` [backquote] Considère le texte quoté comme une commande et la remplace par le résultat de son évaluation. " [double quote] Quote le texte qui le suit en interpolant les éventuelles variables qu'il contient. ! Substitution dans l'historique. | Tube [pipe]. > et >> Redirection de la sortie standard. < et << Redirection de l'entrée standard. # Marque le début d'un commentaire, &ie; pas d'expansion. && Et [And] logique. || Ou [Or] logique. Cette commande exécute le fichier (et ces éventuels arguments) qui lui est passé en argument dans le &shell; courant (&ie; pas de fork et donc modification (éventuelle) du &shell; courant). La commande setenv permet d'initialiser une variable d'environnement, &ie; une variable qui sera transmise à tous les processus fils du &shell;. La commande unsetenv permet de supprimer une variable d'environnement. La commande set a deux fonctions : l'initialisation d'une variable : Cette déclaration permet d'enrichir la variable path du répertoire bin de l'utilisateur. la déclaration d'une option : Cette option permet d'immuniser &fshell; d'une destruction accidentelle. Il est normalement possible de clôre un terminal avec la séquence ^D (lire <CTRL>-D), mais si on positionne l'option ignoreeof la séquence précédente n'a plus d'effet. La commande unset a évidement un effet symétrique. Elle permet donc de désarmer une option ou de supprimer une variable. La portée de ces actions est limitée au &shell; courant contrairement à la commande précédente (&cf; ). Ce mécanisme permet de définir ou de redéfinir une commande. Exemple : En général, on place ces alias dans le fichier ~/.cshrc. Si on veut supprimer un alias on utilise la commande unalias comme suit : Pour ré-accéder à la commande masquée par son alias, comme dans l'exemple précédent où nous avons surchargé la commande classique rm, il suffit de : Soit utiliser la commande par son nom absolu : /bin/rm. Soit faire précéder la commande du caractère backslash (\), on tape donc toujours dans le cadre de l'exemple précédent : \rm Que signifie la commande rm -i ? Cette commande permet de spécifier (si elle est suivie d'un argument valide) ou d'afficher la valeur du masque de création des objets &ie; des fichiers. Ce mécanisme a pour rôle de mémoriser les n dernières commandes entrées, ce nombre étant un paramètre réglable. Cela permet de visualiser, d'éditer et/ou exécuter à nouveau les commandes mémorisées. La commande suivante permet d'activer l'historisation des commandes, elle signifie que les 512 dernières commandes seront mémorisées : La commande suivante permet en plus de sauvegarder les m dernières commandes dans ~/.history au logout. Il est évident que m est au plus égale à n. Ici, nous ne retenons que les 256 dernières commandes : La commande history permet d'afficher les commandes dans l'ordre de leur mémorisation. Makefile 83 9:07 xemacs createinf.sh 84 9:09 which mkdir 85 9:09 rm -rf html/ && make check && make html 86 9:10 ls -l csh/ 87 9:12 echo $$ ]]> Pour relancer une commande, il suffit de l'appeler par son numéro (relativement à l'historique) en la préfixant par le caractère !. Par exemple, si on veut relancer la commande 84, il suffit de faire : Expression Sémantique !! Répéter la dernière commande. !n Répéter la commande numéro n. !-n Répéter la nième précédent la dernière de l'historique, &ie; !-2 : avant dernière commande. !texte Répéter la dernière commande commençant par texte. !?texte Répéter la dernière commande contenant texte. !:n Répéter le nième mot de la dernière commande. !$ Répéter le dernier mot de la dernière commande. !* Répéter tous les arguments de la dernière commande. ^old^new Répéter la dernière commande en commençant par remplacer la première occurence de old par new. !n:s^old^new Répéter la nième commande en commençant par remplacer la première occurence de old par new. !n:gs^old^new Répéter la nième commande en commençant par remplacer toutes les occurences de old par new (substitution globale). Pour terminer, il peut être intéressant de positionner l'alias suivant dans son ~/.cshrc. Que signifie donc cet alias ? En &fshell; la completion est activée par le positionnement de la variable d'environnement filec (&cf; ). Ce mécanisme permet, selon le contexte, de compléter les noms de fichiers ou d'utilisateurs à partir de la saisie d'un préfixe suivi de la frappe du caractère ESC. Le contexte par défaut étant celui de fichiers. Supposons, par exemple, que le contenu du répertoire courant soit le suivant : Alors la séquence suivante : ]]> est résolue en (seule correspondance possible) : $ ls logfile-1.2.pl Tandis que la séquence ci-contre : ]]> est résolue partiellement en : $ ls extract suivit de l'émission d'un bip qui signale que cette expansion est incomplète puisque deux fichiers correspondent au préfixe saisi. La commande précédente suivie du <CTRL>-D permet d'obtenir l'ensemble des réponses potentielles : -D extract.pl* extract_piste.sh* $ ls extract ]]> La saisie d'un seul caractère supplémentaire permet dans ce dernier cas de lever l'ambiguïté. L'utilisation du bip (sonnerie du terminal) pour signaler des erreurs ou des correspondances potentielles peut être désactivée par le positionnement de la variable nobeep. Enfin, il est possible de limiter les correspondances potentielles à la completion en positionnant la variable fignore. Dans l'exemple suivant, on exclut des correspondances possibles les fichiers suffixés en .o, .out et *~. le mécanisme de completion peut être utilisé pour compléter les noms d'utilisateurs. Il faut utiliser le préfixe ~ (il change le contexte de la completion) : $ cd ~pascal ]]> Supposons qu'un utilisateur ait souvent besoin de se rendre alternativement dans le répertoire /home/cvsroot/ et dans son propre répertoire ~/projets, il peut alors : pour se rendre en /home/cvsroot/C-network/, taper : et pour se rendre en ~/projets, taper : Mais, cet utilisateur peut aussi se simplifier la vie en positionnant la variable cdpath, ainsi : Ainsi, il peut se contenter de : taper dans le premier cas : et dans le second : Une pile est une structure de données qui permet de mémoriser des entrées et dont la stratégie d'accès est de type LIFO (Last In, First Out), &ie; on accède uniquement au sommet de la pile. La pile des répertoires est gérée par les trois primitives suivantes : La commande pushd qui permet de changer de répertoire (comme cd), en conservant l'ancien répertoire dans la pile (il est empilé). La commande popd qui permet de changer de répertoire (comme cd), en dépilant le sommet de la pile. La commande dirs qui permet d'afficher le contenu de la pile. L'exemple suivant permet d'en comprendre le fonctionnement : $ pwd /usr/home/ikare/data/travail/Cours/ASR/Cours/Shells $ pushd /usr/local/etc /usr/local/etc ~/data/travail/Cours/ASR/Cours/Shells $ pwd /usr/local/etc $ popd ~/data/travail/Cours/ASR/Cours/Shells $ pwd /usr/home/ikare/data/travail/Cours/ASR/Cours/Shells $ pushd /usr/local/etc /usr/local/etc ~/data/travail/Cours/ASR/Cours/Shells $ pwd /usr/local/etc $ dirs -v 0 /usr/local/etc 1 ~/data/travail/Cours/ASR/Cours/Shells $ more =1/shells.xml Unix"> Unix"> BSD"> i.e."> c.f."> shell">]]> ... encore plein de lignes... Affiche le chemin courant. Se rend dans le répertoire spécifié et l'empile au sommet de la pile. Affiche le chemin courant. Dépile le sommet et se rend dans le répertoire indiqué. Affiche le chemin courant. Affiche le contenu de la pile, en commençant par le sommet. Utilisation de la pile pour lire un fichier situé hors du répertoire courant. Un processus est l'instance d'un programme en exécution. C'est une structure de données qui contient du code statique, des données statiques et dynamiques et un environnement d'exécution. Un processus possède un cycle de vie marqué par des états comme l'exécution (runnable), la suspension, l'attente, le sommeil, l'état zombie... Pour se voir allouer des tranches de temps (time slice) d'exécution sur le CPU, un processus doit être dans l'état exécutable. Chaque programme démarré par le shell nécessite la création d'un nouveau processus, on a ainsi une arborescence de processus, puisqu'une nouvelle instance ne possède qu'un seul parent. L'utilitaire ps permet d'obtenir un instantané des processus en cours $ > ps PID TT STAT TIME COMMAND Process Identifier, identifiant (unique) du processus. TTy device, terminal d'exécution. STATus, état du processus TIME consumed, temps CPU consommé. La commande exécutée. Le système identifie chaque processus au moyen d'un entier appelé pid. Dans l'exemple précédent, la dernière ligne identifie le processus 4370 qui est un shell (tcsh) dans l'état idle, &ie; en sommeil depuis plus de 20 secondes, sur le terminal /dev/ttyp2. La consultation du man 1 ps permet d'obtenir une explication complète de la commande. Voici la sémantique &bsd; associée au premier caractère de la colonne STAT : Caractère Sémantique D Processus en attente d'une E/S disque. I Processus en sommeil depuis plus de 20 secondes. R Processus en exécution sur le CPU. S Processus en sommeil depuis moins de 20 secondes. T Processus suspendu (stoppé) Z Processus Zombie Des caractères additionnels permettent d'avoir des informations supplémentaires, citons le + qui indique un processus d'avant plan (interactif [foreground]) parmi le groupe de processus contrôlé par un terminal. La commande ps l (&cf; exemple suivant) permet d'obtenir plus de détails sur les processus. On y trouve les paramètres suivants : l'uid : propriétaire du processus, le pid : identifiant du processus, le ppid : identifiant du père du processus, le cpu : estimation du temps CPU consommé, le pri : &ie; priorité d'ordonnancement, le nice : priorité assignée par nice ; la modification de cette valeur permet d'influer sur l'algorithme d'ordonnancement [scheduling], le vsz : donne la taille de la mémoire virtuelle utilisée (exprimée en kilo-octet), le rss : taille de la mémoire réelle utilisée (exprimée en kilo-octet). le wchan : le canal d'attente, &ie; l'adresse d'une structure de données identifiant la ressource ou l'évènement pour lequel le processus est en attente, le state : état du processus parmi (R, S, I, Z ...), le tt : le terminal associé au processus, le time : temps cpu accumulé (utilisateur et système), enfin la commande elle-même. L'invocation d'un programme déclenche un nouveau processus chargé de son exécution et pendant ce temps, le &shell; (père du processus) est suspendu jusqu'à la terminaison de ce processus. On parle alors d'éxecution interactive (ou en avant-plan [foreground]). Il est évidement possible d'exécuter un processus de manière asynchrone [background], &ie; de permettre au &shell; d'exécuter de nouvelles commandes immédiatement. Il suffit pour se faire de postfixer la commande à exécuter de manière asynchrone par le caractère ampersand : &. Voici un exemple (noter le numéro du processus : 20713) : &fshell; a introduit la notion de suspension d'un processus interactif par la commande ^Z (lire <CTRL>-Z). La reprise peut se faire de manière asynchrone (arrière plan) par la commande bg ou de manière interactive (avant plan) avec la commande symétrique fg. Pour finir, signalons la commande top qui permet d'avoir des informations en temps réel sur les processus (rafraîchissement toutes les 2 secondes). En voici un exemple tronqué : Les signaux sont une forme limitée de communication inter-processus. Ils permettent de prévenir les processus de l'occurence de certains évènements. Il est possible d'envoyer des signaux à des processus interactifs à partir du clavier. La commande suivante permet de connaître les associations clés/signaux : ; eol2 = ; erase = ^?; erase2 = ^@; intr = ^C; kill = ^U; lnext = ^V; min = 1; quit = ^\; reprint = ^R; start = ^Q; status = ^T; stop = ^S; susp = ^Z; time = 0; werase = ^W; ]]> Ainsi, la séquence <CTRL>-C (^C) permet d'envoyer le signal de terminaison (INT signal), la séquence <CTRL>-\ (^\) permet d'envoyer un autre signal de terminaison (QUIT), la séquence <CTRL>-Z (^Z) permet d'envoyer le signal de suspension (TSTP). Par défaut, les deux premiers signaux (INT et QUIT) termine le processus, tandis que le troisième ne fait que suspendre l'éxecution, &ie; elle peut donc être reprise. Ce comportement par défaut peut cependant être redéfini au sein d'un processus. Sur une architecture 4.4BSD (FreeBSD, NetBSD, OpenBSD) on trouve 31 signaux. La commande, improprement nommée kill (man 1 kill) permet d'envoyer des signaux à un processus. Sa syntaxe est la suivante : kill <signal> <pus>, où <signal> est le signal envoyé au processus de numéro <pus> La liste des signaux délivrable par la commande kill peut être obtenue de la manière suivante : Parmi ces signaux, deux ne peuvent être ni ignorés, ni détournés. Il s'agit du KILL (terminaison) et du STOP (suspension ou stop) (à ne pas confondre avec le TSTP vu précédemment). Cette notion inventée par la branche BSD d'&unix; et introduite par &fshell; est désormais disponible sur toutes les distributions &unix; libres. Un job est soit un processus, soit un groupe de processus lancé par le &shell;. Un job peut être suspendu, redémarré, terminé, executé interactivement ou de manière asynchrone. Le &shell; sait gérer plusieurs jobs simultanément, toutefois à un instant donné seul un job peut avoir accès au terminal. Les jobs sont intéressants dès que les processus qu'ils contrôlent ont une durée de vie de quelques secondes. Analysons la séquence suivante : $ su $ id uid=0(root) gid=0(wheel) groups=0(wheel), 5(operator) $ suspend Interrompu (Signal) $ jobs [1] + Interrompu (Signal) su [2] - Tourne gv data/travail/Cours/ASR/Cours/Shells/shells.pdf $ du -s -h /usr & [3] $ ls50G /usr/home id="com.rep" linkends="rep" /> [3] Exit 1 du -s -h /usr $ ls /usr/home ikare ivan $ stty tostop $ du -s -h /usr/home/ & ... $ jobs [1] - Interrompu (Signal) su [2] Tourne gv data/travail/Cours/ASR/Cours/Shells/shells.pdf [3] + Sortie tty suspendue du -s -h /usr $ %3 du -s -h /usr 50G /usr $ jobs [1] + Interrompu (Signal) su [2] - Tourne gv data/travail/Cours/ASR/Cours/Shells/shells.pdf $ %1 # exit $ jobs [2] - Tourne gv data/travail/Cours/ASR/Cours/Shells/shells.pdf Changement d'identité utilisateur, passe sous root Suspension du processus et restauration de l'identité précédente. Liste des jobs en cours; Lancement d'une nouvelle commande, &ie; un processus de manière asynchrone, celui ci écrira son éventuel résultat sur la sortie standard, sans se préoccuper de ce qu'il peut se passer ! Le résultat de la commande du survient au moment où l'utilisateur tape sa commande ls et pertube donc son affichage. Terminaison du processus. La commande ls s'affiche alors. Pour éviter le mélange précédent, nous bloquons l'écriture du résultat de la commande sur le terminal. Le comportement du processus change, l'utilisateur est informé (variable notify de &fshell;, &cf; ) que le job 3 est prêt à imprimer son résultat (il est suspendu jusqu'à ce qu'il soit autorisé à la faire). On rappelle le job 3, ce qui lui permet d'afficher son résultat. Un job asynchrone qui veut lire sur l'entrée standard alors que ce canal n'a pas été redirigé est toujours suspendu. Il faut le relancer de manière interactive pour qu'il puisse collecter ses données sur l'entrée standard. On rappelle le job 2 et on le termine explicitement par un exit. Il reste alors un seul job en exécution asynchrone. La liste des jobs en cours est donné par la commande jobs. Le caractère % en première position dénote un job. Le tableau suivant (&cf; ) récapitule les différentes manières de référencer un job. Expression Sémantique %n job numéro n. %str job commençant par la chaine str. %?str job contenant la chaine str. Le tableau suivant (&cf; ) donne les commandes de contrôle d'un job. Expression Sémantique bg [name] Place le job name en exécution asynchrone. Si l'argument name n'est pas précisé, la commande s'applique au job courant. name & Place le job name en exécution asynchrone. fg [name] Place le job name en exécution interactive. Si l'argument name n'est pas précisé, la commande s'applique au job courant. name Place le job name en exécution interactive. stop name Suspend le job name. Enfin, la commande kill permet aussi d'envoyer des signaux aux jobs, en utilisant le même référencement des jobs qu'en . Ainsi, la commande suivante met fin au job 1 : En &fshell;, comme en tcsh les processus asynchrones ne sont pas affectés par un logout puisqu'il n'y a pas d'envoi du signal HUP à l'exécution du logout. Corollaire : pas besoin de la commande nohup des autres shells (tel GNU/Bash). Cette commande a pour objet de définir des limites à la consommation des ressources du système par les processus. Il s'agit d'un intervalle définit par une borne haute (hard limits : qui ne peut être modifiée qu'à la baisse, sauf par le super-utilisateur et une borne basse (current limits : qui peut être accrue jusqu'aux valeurs de la borne haute). Rapellons que, sous &unix; en général et sous BSD en particulier, il existe trois canaux d'E/S standard : L'entrée standard [stdin] associée au fd [file descriptor] 0 liée traditionnellement au clavier. La sortie standard [stdout] associée au fd 1, liée traditionnellement à l'écran du terminal. La sortie standard d'erreur [stderr] associée au fd 2, liée traditionnellement à l'écran du terminal. Formellement, un descripteur de fichier est un entier non signé utilisé par les processus pour référencer les canaux d'E/S. La puissance et la flexibilité du concept des canaux standards d'E/S tient essentiellement au fait que le &shell; peut rediriger ces canaux aussi bien sur des fichiers, que l'écran ou le clavier. Symbole Sémantique > <fnom> La sortie standard est redirigée dans le fichier <fnom>. S'il existait, son contenu est perdu et sinon il est créé. >> <fnom> La sortie standard est redirigée dans le fichier <fnom>, ouvert en mode ajout s'il existait, sinon il est créé. >& <fnom> La sortie d'erreur est redirigée dans le fichier <fnom>. S'il existait, son contenu est perdu et sinon il est créé. >>& <fnom> La sortie d'erreur est redirigée dans le fichier <fnom>, ouvert en mode ajout s'il existait, sinon il est créé. < <fnom> L'entrée standard est le fichier <fnom>. << <mot> Lit les entrées du &shell; jusqu'à une ligne commençant (et contenant uniquement) le mot <mot> qui agit comme un marqueur de fin. Le positionnement de la variable interne noclobber, permet d'éviter l'écrasement des fichiers existants dans le cas de l'utilisation des commandes de redirection > et >&. De plus les commandes >> et >>& ne peuvent être exécutées que sur des fichiers existants. Enfin, la sémantique initiale des commandes de redirection (après activation de noclobber) peut être explicitement restituée en utilisant le symbole !. Ainsi, les commandes >!, >>!, >&! et >>&! ont un comportement identique à leurs homologues du tableau précédent (&ie; sans le !, &cf; ). EXEMPLES : file.txt << fin_de_saisie >> première ligne >> puis une 2e >> Encore une autre ! >> C'est pas fini ... >> fin_de_saisie $ ll file.txt -rw-r--r-- 1 ikare ikare 23 20 avr 14:37 file.txt $ cat < file.txt # équivalent à cat file.txt première ligne puis une 2e Encore une autre ! C'est pas fini ... $ ( find /home -name "*~" -print > fout ) >& ferr # séparer les sorties standard (> fout) et d'erreur (>& ferr) $ cat fout # les résultats /usr/local/www/data/tyle_docbook.css~ /usr/local/www/data/docbook_ikare.css~ /usr/local/www/data/_my_style.css~ /usr/local/www/data/freebsd.css~ /usr/local/www/data/styleswitcher.js~ /usr/local/www/data/style_docbook.css~ /usr/local/www/data/style.css~ /usr/local/www/kurzweg/Cnfpt2006/index.php~ /usr/local/www/kurzweg/bts/admin/ccf.php~ /usr/local/www/kurzweg/bts/admin/ccf_liste_stag.php~ /usr/local/www/kurzweg/bts/admin/ccf_stag.php~ /usr/local/www/kurzweg/cnam/nfa001/haut.php~ /usr/local/www/kurzweg/styleswitcher.js~ /usr/local/www/kurzweg/_my_style.css~ /usr/local/www/kurzweg/style.css~ /usr/local/www/kurzweg/style_docbook.css~ /usr/local/www/kurzweg/tyle_docbook.css~ /usr/local/www/kurzweg/docbook_ikare.css~ /usr/local/www/kurzweg/freebsd.css~ $ cat ferr # les erreurs find: /usr/local/etc/cups/ssl: Permission denied ]]> Le mécanisme de pipeline consiste à rediriger la sortie d'une commande vers l'entrée d'une autre. D'un point de vue syntaxique nous avons la structure suivante : | ]]> La sortie de la commande ls -l est redirigée vers l'entrée de la commande sort -k 5n. Que permet de réaliser la commande précédente ? Enfin, en postfixant au tube ('|' ou encore pipe) l'ampersand (&), il est possible de combiner les sorties standard et d'erreur vers l'entrée de la commande qui suit (le tube). |& ]]> Comment ajouter le contenu de fichier 1 à fichier 2? Combien y a t-il de processus actifs sur le système ? (Utilisez la commande ps) Combien d'utilisateurs sont connectés sur le système? Afficher la liste des utilisateurs connectés triée par ordre alphabétique, puis selon l'heure de connexion Combien le répertoire /usr/local/etc a-t-il de sous répertoire? (ls -F) Comment afficher la liste des fichiers contenus dans le répertoire /usr/local/bin, triés par ordre croissant sur le numéro d'inode (ls -i) ? Comment afficher ce résultat sur une imprimante ? Afficher la liste des fichiers du répertoire courant par ordre de taille. Rechercher la chaîne erreur dans un fichier, sans tenir compte de la différence entre les lettres majuscules et minuscules. Construisez un fichier ~/tmp/foo contenant l'ensemble des variables du shell Ces structures algorithmiques sont utilisées dans les scripts &shell;s. Pour rédiger un script &shell; (ici, en &fshell2;), il faut : Créer le fichier avec un éditeur de texte (sample.sh). La première ligne doit commencer avec le prologue [shebang] : #!/bin/tcsh. Lui attribuer la permission d'exécution sur le fichier créé (chmod +x sample.sh). Enfin, pour l'exécuter il suffit de taper le nom du fichier, puisque c'est désormais une nouvelle commande (si on est dans le répertoire courant de cette commande, il suffit de taper ./sample.sh). Nous donnons dans ce qui suit, quelques exemples de scripts &shell;s (&fshell;). Cette structure permet l'exécution conditionnelle d'une instruction. Voici sa syntaxe : ) then else if ( ) then else if ( ) then else endif ]]> &_fcomp; Cette structure permet l'exécution conditionnelle d'une instruction. ) case motif1 : breaksw case motif2 : case motif3 : breaksw case motif4 : case motif5 : default: endsw ]]> &_fdate; $ fdate.sh Sam 12 Avr 2003, 21:20:45 [RET] Il s'agit de l'instruction standard qui permet d'exécuter le corps de la boucle tant que la condition d'entrée est vérifiée (valeur évaluée à vrai). ) end ]]> Cette instruction permet de répéter un nombre entier de fois une même commande. ]]> Cette instruction permet de traiter en séquence tous les éléments d'une liste. ( ) end ]]> Ce sont les variables que les utilisateurs peuvent définir. Le &shell; étant un langage interprété non typé, aucune déclaration n'est nécessaire et la même variable peut contenir tour à tour une chaîne de caractères, un entier, ou un vecteur (tableau d'éléments de type chaîne de caractères ou entier, indexé par des entiers, commençant à 1). Cette opération permet d'associer un contenu à une variable (le contenant). En &fshell; comme en &fshell2;, l'affectation se fait en utilisant la commande interne set de la manière suivante : EXEMPLE : L'accès au contenu de la variable se fait en préfixant le nom de la variable par le symbole $. EXEMPLE (SUITE) : On peut aussi encadrer la variable par les symboles { et } avant de la préfixer par le symbole $ : EXEMPLE (SUITE) : L'accès à une variable non définie produit (sauf rares exceptions) une erreur (en &fshell;, comme en &fshell2;). Cette opération permet de libérer la case mémoire occupée par la variable. Cela se fait en &fshell; comme en &fshell2;, en utilisant la commande interne unset de la manière suivante : EXEMPLE (SUITE) : Voici un exemple : CODE : EXEMPLE : Les modificateurs [modifiers] suivants peuvent être appliqués aux variables. On travaillera avec l'exemple (un vecteur) suivant : Clé Sémantique Exemple :h   :gh interprète le contenu de la variable comme un nom de fichier &unix; et en donne le début, &ie; la partie avant le dernier / :t   :gt interprète le contenu de la variable comme un nom de fichier &unix; et en donne la fin, &ie; la partie après le dernier / :r   :gr supprime l'extension en fin de variable. :e   :ge donne l'extension correspondant à la fin de variable. :q   :gq quote la variable pour éviter tout mécanisme de substitution. :x   :gx idem précédent, mais cassure en mots sur les caractères : blanc, espace et nouvelle ligne. Clé Sémantique $?<name> = ${?<name>} Renvoit 1 si la variable est définie, 0 sinon. $?0 Renvoit 1 si $0 est définie, 0 sinon. $$ Substituée par le pid du &shell; parent. $! Substituée par le pid du dernier processus asynchrone lancé par le &shell; parent. $< Substituée par une ligne de l'entrée standard. Le &shell; définit pour chaque commande un certain nombre de paramètres automatiques. Paramètre(s) Utilisation $0 nom de la commande ou du script invoqué. $1, $2 .. $n   ${1}, ${2} .. ${n} encore équivalent à $argv[1], $argv[2], .. $argv[n]    valeurs des paramètres positionnels passés à la commande ou au script. $* = $argv[*]     = ${argv[*]} ensemble des paramètres, sauf $0. $# = $#argv      = ${#argv} nombre de paramètres effectifs, $0 non compris. CODE : 0 ) then echo ' évoqué avec $# (= $#argv = ${#argv}) = ' ${#argv} ' arguments sur la ligne de commande' echo 'Voici les paramètres : $* (= $argv[*] = ${argv[*]}) = ' ${argv[*]} set i = 1 foreach param ( $argv[*] ) echo "paramètre ($i) : $param" @ i++ end else echo ' pas d arguments, nb arg $# (= $#argv = ${#argv}) = ' ${#argv} endif # fin du script ]]> EXEMPLE : Elle se fait en utilisant la variable spéciale $< CODE : EXEMPLE : Règles : Les expressions utilisent les mêmes opérateurs que le langage C (sémantique identique. On retrouve les instructions if, while, @ et exit, Les chaines numériques commençant par un 0 sont interprétées comme des valeurs en base octale, Le résultat de toute expression est une chaîne représentant un nombre décimal. La valeur 0 s'interprète en contexte logique comme la valeur faux, toutes les autres ont la valeur vrai. Opérateur Sémantique O P E R A T E U R S    D E    F I C H I E R S -d <filename> est vraie si le fichier désigné par <filename> est un répertoire. -e <filename> est vraie si le fichier désigné par <filename> existe. -f <filename> est vraie si le fichier désigné par <filename> est un fichier régulier. -o <filename> est vraie si le fichier désigné par <filename> est propriété de l'utilisateur. -r <filename> est vraie si le fichier désigné par <filename> est un fichier accessible en lecture. -w <filename> est vraie si le fichier désigné par <filename> est un fichier accessible en écriture. -x <filename> est vraie si le fichier désigné par <filename> est un fichier exécutable. -z <filename> est vraie si le fichier désigné par <filename> est de taille nulle. -b <filename> [&fshell2;] est vraie si le fichier désigné par <filename> est un fichier spécial en mode bloc. -c <filename> [&fshell2;] est vraie si le fichier désigné par <filename> est un fichier spécial en mode caractère. -l <filename> [&fshell2;] est vraie si le fichier désigné par <filename> est un lien symbolique. -p <filename> [&fshell2;] est vraie si le fichier désigné par <filename> est un tube nommés (FIFO). -S <filename> [&fshell2;] est vraie si le fichier désigné par <filename> est un socket. C O M P A R A I S O N    D E    C H A I N E S <str1> == <str2> est vraie si <str1> est égale à <str2>. <str1> != <str2> est vraie si <str1> est différente de <str2>. <str1> =~ <str2> est vraie si le motif <str2> (right hand side) correspond au motif <str1>. <str1> !~ <str2> est vraie si le motif <str2> (right hand side) ne correspond pas au motif <str1>. C O M P A R A I S O N    D ' E N T I E R S <int1> >= <int2> est vraie si <int1> est supérieur ou égal à <int2>. <int1> > <int2> est vraie si <int1> est strictement supérieur à <int2>. <int1> <= <int2> est vraie si <int1> est inférieur ou égal à <int2>. <int1> < <int2> est vraie si <int1> est strictement inférieur à <int2>. C O M B I N A I S O N    D ' E X P R E S S I O N S ( <expr> ) est vraie si <expr> est vraie. ! <expr> est vraie si <expr> est fausse. <expr1> && <expr2> est vraie si <expr1> et <expr2> sont simultanément vraies. <expr1> || <expr2> est vraie si <expr1> ou <expr2> est/sont vraie(s). Opérateurs Sémantique (   ) regroupement ~ complément bit à bit ! négation logique. *   /   % multiplication, division, modulo +   - addition, soustraction <<   >> décalage à gauche, décalage à droite <=   <   >=   > opérateurs relationnels ==   !=   =~   !~ opérateurs de comparaisons de chaînes & et bit à bit ^ ou exclusif bit à bit | ou (inclusif) bit à bit && et logique || ou logique La commande interne @ permet de réaliser des opérations arithmétiques sur des valeurs ou variables entières, attention à respecter l'espace entre le symbole @ et la variable. > 2 ) # 10 décaler de 2 bits à droite, soit 10 / 4 = 2 $ echo $v 2 ]]> Sous &fshell2; le mécanisme de completion des noms a été amélioré. Ce &shell; peut compléter les noms des fichiers, des commandes et des variables. De plus la completion des noms de fichiers est programmable ! La completion est déclenchable par la touche <TAB>, bien que par compatibilité ascendante avec &fshell;, la touche <ESC> reste opérationnelle. Il faut utiliser le préfixe $ (il change le contexte de la completion) : $ echo $varia_1 10 ]]> Cette commande permet l'édition des commandes en ligne dans un buffer au moyen des contrôles associés aux éditeurs classiques d'&Unix;, à savoir vi ou emacs. Utilisée seule, elle retourne la liste des associations clés/commandes. Le positionnement par défaut est souvent le mode emacs, il est déterminé à la compilation. La variable version permet de connaître la version de la commande ainsi que les options de compilation. Dans l'exemple suivant, l'absence de la clé vi, permet d'affirmer que le mode par défaut est emacs. Cette commande permet aussi de commuter entre le mode vi et le mode emacs. Dans le tableau suivant, nous présentons un sous-ensemble des commandes d'édition : Clé Commande ^A Positionne le curseur en début de ligne ^B Recule horizontalement le curseur d'un caractère ^E Postionne le curseur en fin de ligne ^L Efface l'ecran ^K Coupe tous les caractères à la droite du curseur ^T Transposition de caractères ^M Nouvelle ligne ^U Efface toute la ligne ^C Signal d'interruption ^Z Signal de suspension Backspace Efface le premier caractère situé à gauche du curseur Flèche gauche Déplacement d'un caractère à gauche du curseur Flèche droite Déplacement d'un caractère situé à droite du curseur Flèche haut Remonte dans l'historique des commandes (vers les commandes les plus anciennes) Flèche bas Descend dans l'historique des commandes Ce mécanisme est déclenché en postionnant la variable (interne) &fshell2; correct (valeurs possibles cmd ou all) : less test.csh (y|n|e|a)? yes # frappe de la touche y ou #!/bin/csh # lecture et affichage du fichier echo '\nJe suis le programme $0 : ' $0 ... ]]> Soit les affectations suivantes : Tester les commandes suivantes et expliquer dans chaque cas le résultat obtenu. Tester les commandes suivantes et expliquer dans chaque cas le résultat obtenu. Dans un terminal, sous le &shell; courant définir deux variables (var1 et var2) et modifier quelques variables d'environnement. Afficher l'environnement ainsi modifié. Dans ce même terminal, empiler un nouveau shell (/bin/tcsh). Quelle sont les valeurs de var1 et var2, des variables d'environnement ? Définir une variable var3. Quitter ce &shell; et revenir à l'environnement initial (exit). Examiner son environnement, que vaut var3 ? Conclure. Exporter maintenant la variable var1, empiler un nouveau &shell;. Examiner son environnment. Modifier ensuite var1. Définir la variable var2. Quitter ce &shell;, pour revenir à celui de départ. Quelles sont les valeurs de var1 et var2 ? Et si avant de quitter ce &shell; empilé, vous aviez exporté la variable var2, qu'auriez-vous obtenu ? Exécuter la commande suivante dans un premier terminal, et dans un second ouvert pour l'occasion, lister les processus en cours d'exécution (se limiter aux seuls processus du terminal générateur), observer leur filiation, le nombre de processus : Observer l'entrelacement des résulats de ces commandes. La séquence backslash (&ie; \), suivit de la touche <Entrée> indique au &shell; une continuation de la commande sur la ligne suivante. Que fait la commande sleep ? Lancer la commande suivante : find / -type d -print, laquelle recherche tous les objets de type répertoire dans toute l'arborescence. La recherche se fait de manière récursive et comme l'arborescence est grande, l'exécution est un peu longue. On est bloqué tant que le processus exécutant le find n'est pas terminé. Il vous est demandé de : suspendre (ou stopper) le processus. de le relancer en arrière-plan de le ramener au premier plan de le terminer. Est-il possible de tuer des processus ne vous appartenant pas ? Tester-le. Si vous n'êtes pas assez rapide ou bien si la commande s'exécute trop rapidement, ouvrir un nouveau terminal et refaire le travail demandé. Reprendre l'exemple de la commande find, de la section , mais limiter la recherche au répertoire /etc. Rediriger uniquement la sortie d'erreur dans le fichier (ferr) ; Rediriger uniquement la sortie standard dans un fichier (fout) ; Multiplexer les sorties standard et d'erreur dans le même fichier (fouterr) ; Rediriger (démultiplexer) la sortie standard et la sortie d'erreur dans les fichiers respectifs (fout et ferr). Reprenez l'exercice sur les noms de domaines. Automatisez tous les traitements à l'aide d'un script csh. Ajoutez les fonctionnalités suivantes : Le fichier à traiter est un fichier à télécharger sur Internet. L'utilisateur donne l'URL du fichier. Possibilité de donner plusieurs URLs. Les traitements aboutissent sur seulement 2 fichiers : un avec les adresses IP et l'autre avec les noms de domaines. 0 OpenBSD man pages man csh Janvier 1994 1 Heuer Konrad Décembre 2001 2 Heuer Konrad Janvier 2002 3 Heuer Konrad Février 2002 4 University of Hawaii at Manoa - College of Engineering csh tutorial 2001 5 Pélissier Christian Utilisation, Administration, Réseau Internet Chap 9, pp 163-176 HERMES 1992, 1995, 1996, 1998 isdn : 2-86601-707-2