$Id: C-bash.xml,v 1.2.1.2 2005/05/14 06:10:47 pascal Exp $ &_aut_Pre; &_aut_Nom; &_affiliat; Last Updated: $Date: 2005/05/14 06:10:47 $ &_aut_Init; 2002-2005, 2006 &_holder; 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. THE DOCUMENTATION IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS DOCUMENTATION INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS DOCUMENTATION. interprète de commande, shell, bash, 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, un successeur de sh munit de fonctionnalités étendues par rapport à son ancêtre. &fshell; est un shell compatible sh, développé dans le cadre du projet GNU. C'est une amélioration de csh et ksh, tant dans l'utilisation interactive qu'au niveau de la programmation. Il se conforme au standard IEEE POSIX P1003.2/ISO 9945.2 et c'est le shell par défaut des systèmes &glinux;. Me joindre : &_aut_eMail; 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 rend, 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 .. fi, for ... ... 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 ou par une fonction. il possède un mécanisme d'historisation, de rappel et d'éditions des commandes ; il permet le contrôle des processus/jobs (suspension), reprise asynchrone (background) ou interactive (foreground)) ; il permet de traiter les tableaux de caractères ; il permet de définir des fonctions et des variables locales aux fonctions ; il gère l'arithmétique des entiers dans les bases 2 à 64 ; il possède un mécanisme de completion. Lors du login de connexion, &fshell; exécute les instructions contenues dans le fichier /etc/profile puis celles du fichier ~/bash_profile s'il existe et sinon ~/.bash_login s'il existe (et sinon ~/.profile). Les scripts précédent peuvent éventuellement activer l'exécution de ~/.bashrc, lequel peut à son tour lancer /etc/bashrc. La signification du caractère ~ est donnée en . Lors de la fin de session (logout) &fshell; exécutent les commandes du fichier ~/bash_logout. Un sous-&shell;, ne lit que le fichier ~/.bashrc à son démarrage et rien à sa terminaison. De ce qui précède, on déduit que les commandes à exécuter une seule fois pendant une session sont à placer dans le fichier ~/.bash_profile (typiquement les variables d'environnement), tandis que les autres sont à placer dans le fichier ~/.bashrc. Le fichier ~/.bash_profile contient essentiellement la définition des variables d'environnement. Le fichier ~/.bashrc contient typiquement : la définition des alias ; la définition des paramètres de fonctionnement ; l'initialisation des variables. & /dev/null fi ]]> Le fichier ~/.bash_logout contient essentiellement des commandes de suppression de fichiers inutiles, exécutées typiquement à la déconnexion. /dev/nul l \) echo "... done" echo "last connexion at [`date +%Y-%m-%d` a `date +%H:%M:%S`] pour [`logname`] s ur [`tty`]" > ~/.deconnex ]]> Quel est le rôle de la commande find dans le contexte du listing précédent (~/.bash_logout) ? Il est possible à tout moment et notamment après une modification de réexécuter les fichiers au moyen de la commande source (l'exécution se fait dans le contexte du &shell; courant, &ie; modification de l'environnement courant). $ source ~/.bash_profile $ source ~/.bashrc 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;), elles sont utilisées par certaines commandes du &shell; ou du système. Variable d'environnement Sémantique BASH Donne le chemin absolu du shell (typiquement /bin/bash). BASH_VERSION Donne la version du shell (ici 2.05b.0(1)-release). CDPATH Liste des répertoires explorés par la commande cd. EUID UID (identifiant) effectif de l'utilisateur courant. FIGNORE Liste de suffixes de fichiers qui ne doivent pas apparaître dans l'expansion. (typiquement *~:*.o:*.bak) HISTCMD Numéro de la commande courante dans l'historique. HISTCONTROL Peut prendre trois valeurs : ignoredups, ignorespace, ignoreboth de sémantique respective suivante : la ligne courante n'est pas rajoutée à l'historique si elle est identique à la précédente, une ligne commençant par un blanc n'est pas ajoutée à l'historique, enfin la dernière combine les deux précédentes. HISTFILE Le fichier historique (typiquement ~/.bash_history). HISTFILESIZE Nombre de lignes maximum de l'historique (par défaut 500). HISTSIZE Nombre de commandes mémorisées par la commande history (par défaut 500). HOSTNAME Nom (court) de la machine. HOSTTYPE Architecture de la machine (pour un PC i386). 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. IFS (Internal Field Separator) Contient le/les séparateur(s) de champs, par défaut <space><tab><newline>. IGNOREEOF Contrôle l'action du shell interactif sur réception du caractère EOF. Si cette variable est positionnée (numériquement), elle correspond au nombre consécutif de caractères EOF à taper sur la ligne courante pour sortir de &fshell;. Sa valeur par défaut est de 10 si la variable existe, sinon elle signifie la fin d'une entrée pour le shell. MAIL Indique le fichier dans lequel le &shell; contrôle l'arrivée de nouveaux messages. MAILCHECK Définit la fréquence de vérification d'arrivée de nouveaux couriers (par défaut 60s, &ie; une vérification toutes les minutes). PATH Définit l'ensemble des chemins dans lesquels le &shell; recherche les commandes externes à exécuter. PPID PID (Process IDentifier) père du processus courant. PS1 Définit l'invite de commandes en mode interactif (par défaut $). PS2 Définit l'invite de commandes secondaire en mode interactif (par défaut >). PS3 Définit l'invite de la structure de boucle select (par défaut #?). PS4 Définit l'invite de trace (par défaut +). PWD Chemin absolu du répertoire courant. RANDOM A chaque appel à cette variable un entier dans l'intervalle [0..32767] est aléatoirement généré. SECONDS Temps écoulé en secondes depuis le lancement du shell courant. SHLVL Nombre d'instance(s) de shell lancé(s). UID Idenfifiant de l'utilisateur courant. NO_CLOBBER 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. 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 commençant par le motif C-csh_n_tcsh du répertoire courant : Exemple : Lister les fichiers (non cachés) du répertoires courant : 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 C-csh_n_tcsh et dont le suffixe est réduit à deux caractères : echo C-csh_n_tcsh.?? C-csh_n_tcsh.fo C-csh_n_tcsh.ps ]]> 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' : Autre exemple, utilisation de la négation, marquée 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 qui le suit immédiatement. ' [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. Ces commandes synonymes exécutent le fichier (et ces éventuels arguments) qui leur est passé en argument dans le shell courant (&ie; par de fork). La commande export permet d'initialiser une variable d'environnement, &ie; une variable qui sera transmise à tous les processus fils du &shell;. La commande unset permet de supprimer le contenu d'une variable (d'environnement ou autre). 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 ~/.bashrc. 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 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 (&cf; variables d'environnements HISTSIZE et HISTFILESIZE). Cela permet de visualiser, d'éditer et/ou exécuter à nouveau les commandes mémorisées. 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 99, 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). Ce mécanisme permet, selon le contexte, de compléter les noms de fichiers, d'utilisateurs, de machines ou de variables à partir de la saisie d'un préfixe suivi de la frappe du caractère TAB. 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 : suivie 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 à nouveau de la séquence <TAB> permet d'obtenir l'ensemble des réponses potentielles : 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é. 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 ]]> le mécanisme de completion peut être utilisé pour compléter les noms de variables. Il faut utiliser le préfixe $ (il change le contexte de la completion) : $ echo $varia_1 10 ]]> le mécanisme de completion peut être utilisé pour compléter les noms de machines. Il faut utiliser le préfixe @ (il change le contexte de la completion) : $ @tux $ @tux.corto.home ]]> 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é par les trois primitives suivantes : La commande pushd permet de changer de répertoire (comme cd), mais l'ancien répertoire est conservé dans la pile (il est empilé). La commande popd permet de changer de répertoire (comme cd), en dépilant le sommet de la pile. La commande dirs permet d'afficher le contenu de la pile. L'exemple suivant permet d'en comprendre le fonctionnement : $ pwd /home/pascal/enseignement/NeoTechIII/V2L-PRAI/csh $ pushd /usr/local/etc /usr/local/etc ~/enseignement/NeoTechIII/V2L-PRAI/csh $ pwd /usr/local/etc $ popd ~/enseignement/NeoTechIII/V2L-PRAI/csh $ pwd /home/pascal/enseignement/NeoTechIII/V2L-PRAI/csh $ pushd /usr/local/etc /usr/local/etc ~/enseignement/NeoTechIII/V2L-PRAI/csh $ pwd /usr/local/etc $ dirs -v 0 /usr/local/etc 1 ~/enseignement/NeoTechIII/V2L-PRAI/csh 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. 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 TTY      TIME CMD Process IDentifier, identifiant (unique) du processus. TTY device, terminal d'exécution. 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 première ligne identifie le processus numéro 544, qui un shell (&fshell;) sur le terminal /dev/pts/0. 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 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; une adresse sur 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, T, Z ...), le tty : 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 processu) 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; reprend le mécanisme de suspension d'un processus interactif (introduit par csh 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 3 secondes, par défaut sous Debian). 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 : Ainsi, la séquence <CTRL>-C (^C) permet d'envoyer le signal de terminaison (SIGINT signal), la séquence <CTRL>-\ (^\) permet d'envoyer un autre signal de terminaison (SIGQUIT), la séquence <CTRL>-Z (^Z) permet d'envoyer le signal de suspension (SIGTSTP). Par défaut, les deux premiers signaux (SIGINT et SIGQUIT) 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 &glinux; on trouve 62 signaux. La commande, improprement nommée kill (&cf; 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élivrables 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 SIGKILL (terminaison) et du SIGSTOP (suspension ou stop) (à ne pas confondre avec le SIGTSTP vu précédemment). Cette notion inventée par la branche BSD d'&unix; et introduite par csh 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 toor Password: # id uid=0(root) gid=0(wheel) groups=0(wheel) # suspend Suspended $ jobs [1] - Running xemacs C-csh_n_tcsh.xml [2] + Suspended su toor $ du -s -h /usr & [3] 21136 $ ls3.7G /usr [3] Exit 1 du -s -h /usr $ ls /usr C-csh_n_tcsh.xml Makefile _mystyle.xsl images my_style.xsl CVS _mystyle.css html my_print.dsl $ du -s -h /usr & ... $ jobs [1] Running xemacs C-csh_n_tcsh.xml [2] - Suspended su toor [3] + Suspended (tty output) du -s -h /usr $ %3 du -s -h /usr 3.7G /usr $ jobs [1] - Running xemacs C-csh_n_tcsh.xml [2] + Suspended su toor $ %2 # exit $ jobs [1] + Running xemacs C-csh_n_tcsh.xml Changement d'identité utilisateur. 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. Le comportement du processus change, l'utilisateur est informé 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ée 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;, tous les processus (y compris les processus asynchrones) sont terminés lors d'un logout, l'exécution de cette commande déclenchant l'envoi du signal SIGHUP à tous les processus fils. Si un processus doit poursuivre son exécution au-delà du &shell; qui lui a donné naissance, il faut utiliser la commande nohup (&cf; man 1 nohup). 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 (H : qui ne peut être modifiée qu'à la baisse, sauf par le super-utilisateur) et une borne basse (S : qui peut être accrue jusqu'aux valeurs de la borne haute). Rapellons que, sous &unix; en général et sous &glinux; 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éé. 2> <fnom> La sortie d'erreur est redirigée dans le fichier <fnom>. S'il existait, son contenu est perdu et sinon il est créé. 2>> <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 NO_CLOBBER, 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------- 1 pascal gnu - 65 Aug 1 15:58 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 1> fres ) 2> ferr # séparer les sorties standard (> fres) et d'erreur (2> ferr) $ cat fres # les résultats /home/pascal/enseignement/NeoTechIII/V2L-PRAI/CS2-csh/toto.sh~ /home/pascal/enseignement/NeoTechIII/V2L-PRAI/Progr-V2L/Progr-V2L.xml~ /home/miji/work/these/annexes/annexes.sxw~ /home/miji/work/these/partie1/part_legende/legendes.sxw~ /home/hosts/corto-home/turing/postfix/main.cf~ /home/hosts/corto-home/euler/ulocal-etc/flexbackup/flexbackup.conf~ /home/hosts/corto-home/euler/ulocal-etc/tripwire/twpol.txt~ /home/hosts/corto-home/euler/etc/ssh/sshd_config~ /home/hosts/corto-home/tux/etc/apache/httpd.conf~ /home/hosts/corto-home/tux/etc/apache-ssl/httpd.conf~ $ cat ferr # les erreurs find: /home/miji/.ssh: Permission denied find: /home/miji/work/lit_reu/Dayot: Permission denied find: /home/miji/Choices: Permission denied find: /home/miji/pdf: Permission denied find: /home/miji/tmp: Permission denied find: /home/miji/.Eterm: Permission denied find: /home/miji/.mozilla: Permission denied find: /home/miji/.mutt: Permission denied find: /home/miji/.netscape: Permission denied find: /home/miji/.prefs: Permission denied find: /home/miji/.vnc: Permission denied find: /home/miji/.Gabber: Permission denied find: /home/miji/.wmakerconf: 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 ? Ces structures algorithmiques sont utilisées dans les scripts &shell;s. Pour rédiger un script &shell; (ici, en &fshell;), il faut : Créer le fichier avec un éditeur de texte (sample.sh). La première ligne doit commencer avec le prologue [shebang] : #!/bin/bash. 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 (les deux formes sont équivalentes) : ]; then if test ; then elif [ ]; then elif test ; then elif [ ]; then elif test ; then else else fi fi ]]> &_fcomp; Cette structure permet l'exécution conditionnelle d'une instruction. in motif11|motif12|... ) ;; motif21|motif22|... ) ;; motif3) ;; motif4) ;; *) ;; esac ]]> &_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). ]; do done ]]> Il s'agit de l'instruction standard qui permet d'exécuter le corps de la boucle jusquà ce que la condition d'entrée soit vérifiée (valeur évaluée à vrai). ]; do done ]]> Cette instruction permet de traiter en séquence tous les éléments d'une liste. in ; do done ]]> Ce sont les variables que les utilisateurs peuvent définir. Le &shell; étant un langage interprété non typé, aucune déclarartion 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 à 0). Cette opération permet d'associer un contenu à une variable (le contenant). En &fshell; l'affectation se fait en utilisant de la manière suivante (noter bien l'absence d'espace autour du symbole =) : 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 ne produit pas d'erreur en &fshell;. Cette opération permet de libérer la case mémoire occupée par la variable. Cela se fait en &fshell; en utilisant la commande interne unset de la manière suivante : EXEMPLE (SUITE) : Voici un exemple : CODE : &_ftestv; EXEMPLE : Clé Sémantique ${#<name>} Donne le nombre de caractères du contenu de la variable ${<name>:-<value>} Renvoit la valeur de la variable <name> si elle existe et sinon <value> (il n'y a pas affectation). ${<name>:=<value>} Renvoit la valeur de la variable <name> si elle existe et sinon affecte <value> à <name> et renvoit la valeur. ${<name>:?<value>} Affiche <value> sur la sortie d'erreur standard si <name> n'est pas définie et réalise un exit s'il ne s'agit pas d'un shell interactif ${<name>:+<value>} Affiche <value> si <name> est définie et rien sinon ${<name>#<motif>} Supprime de <name> le motif <motif> le plus petit correspondant à gauche. ${<name>##<motif>} Supprime de <name> le motif <motif> le plus grand correspondant à gauche. ${<name>%<motif>} Supprime de <name> le motif <motif> le plus petit correspondant à droite. ${<name>%%<motif>} Supprime de <name> le motif <motif> le plus grand correspondant à droite. EXEMPLE : D'après l'exemple qui précède, comment n'obtenir que le nom du fichier, sans le chemin complet et sans le suffixe (en deux temps) ? 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 .. $9 valeurs des paramètres positionnels passés à la commande ou au script. $* ensemble des paramètres, sauf $0. "$#" vaut "$1 $2 ..." $@ ensemble des paramètres, sauf $0. "$@" vaut "$1" "$2" ... $# nombre de paramètres effectifs, $0 non compris. $- les options courantes du shell $? le code de retour de la dernière commande $$ le pid du shell parent $! le pid du dernier processus asynchrone lancé par le shell parent $_ le dernier argument de la commande précédente CODE : &_ftestp; EXEMPLE : Voici une liste non exhaustive des principaux opérateurs de comparaison : Opérateur Sémantique O P E R A T E U R S    D E    F I C H I E R S -b <filename> est vraie si le fichier désigné par <filename> est un fichier spécial en mode bloc. -c <filename> est vraie si le fichier désigné par <filename> est un fichier spécial en mode caractères. -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. -g <filename> est vraie si le fichier désigné par <filename> a le setgid bit activé. -k <filename> est vraie si le fichier désigné par <filename> a le sticky bit activé. -u <filename> est vraie si le fichier désigné par <filename> a le setuid bit activé. -G <filename> est vraie si le fichier désigné par <filename> appartient au groupe (egid). -O <filename> est vraie si le fichier désigné par <filename> appartient à l'utilisateur effectif du processus (euid). -L <filename> est vraie si le fichier désigné par <filename> est un lien symbolique. -p <filename> est vraie si le fichier désigné par <filename> est un fichier spécial FIFO (tube nommé). -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. <filename1> -nt <filename2> est vraie si <filename1> est plus récent que <filename2>. <filename1> -ot <filename2> est vraie si <filename1> est plus vieux que <filename2>. C O M P A R A I S O N    D E    C H A I N E S -n <str> est vraie si <str> a une longueur non nulle. -z <str> est vraie si <str> a une longueur nulle. <str1> = <str2> est vraie si <str1> est égale à <str2>. <str1> != <str2> est vraie si <str1> est différente de <str2>. C O M P A R A I S O N    D ' E N T I E R S <int1> -eq <int2> est vraie si <int1> est égal à <int2>. <int1> -ne <int2> est vraie si <int1> est différent <int2>. <int1> -ge <int2> est vraie si <int1> est supérieur ou égal à <int2>. <int1> -gt <int2> est vraie si <int1> est strictement supérieur à <int2>. <int1> -le <int2> est vraie si <int1> est inférieur ou égal à <int2>. <int1> -lt <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> -a <expr2> est vraie si <expr1> et <expr2> sont simultanément vraies. <expr1> -o <expr2> est vraie si <expr1> ou <expr2> est/sont vraie(s). Règles : Les instructions arithmétiques apparaissent dans l'instruction let et dans l'expansion arithmétique. Les constantes commençant par 0 (resp. 0x) sont interprétées comme des valeurs en base octale (resp. héxadécimale). Une constante entière peut être exprimée dans une base de l'intervalle [2, 64], en la préfixant par l'expression base#. La base par défaut est 10. Les variables du shell sont autorisées comme opérandes dans les expressions arithmétiques, l'expansion (substitution de la variable par sa valeur) ayant lieu, logiquement, avant l'évaluation de l'expression arithmétique. Soit les affectations suivantes : Tester les commandes suivantes et expliquer dans chaque le résultat obtenu. Tester les commandes suivantes et expliquer dans chaque 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/bash). 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 les erreurs dans un fichier (ferr) ; Rediriger uniquement les sorties dans un fichier (frep) ; Rediriger les sorties et les erreurs dans un même fichier (freperr) ; Rediriger les sorties et les erreurs dans leurs fichiers respectifs (frep et ferr). 0 GNU/Bash dernière maj : 13.11.2001 1 GNU/Bash home page 2 Robbins Daniel drobbins@gentoo.org 3 Robbins Daniel drobbins@gentoo.org 4 Robbins Daniel drobbins@gentoo.org