Cette commande exécute le fichier (et ces éventuels arguments) qui lui est passé en argument dans le shell courant (i.e. pas de fork et donc modification (éventuelle) du shell courant).
$ source ~/.login
La commande setenv permet d'initialiser une variable d'environnement, i.e. une variable qui sera transmise à tous les processus fils du shell.
setenv OSTYPE FreeBSD setenv CPUTYPE k7 setenv PAGER less
La commande unsetenv permet de supprimer une variable d'environnement.
La commande set a deux fonctions :
l'initialisation d'une variable :
$ set path=( $path ~/bin )
Cette déclaration permet d'enrichir la variable path du répertoire bin de l'utilisateur.
la déclaration d'une option :
$ set ignoreeof
Cette option permet d'immuniser csh 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.
Important
La portée de ces actions est limitée au shell courant contrairement à la commande précédente (c.f. Section 2.2, « setenv/unsetenv »).
Ce mécanisme permet de définir ou de redéfinir une commande. Exemple :
$ alias la /bin/ls -aoBG # definition de l'alias la $ alias rm /bin/rm -i # definition de l'alias rm $ alias # afficher les alias courants la (/bin/ls -aoBG) rm (/bin/rm -i)
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 :
$ unalias rm $ alias # afficher les alias courants la (/bin/ls -aoBG)
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 i.e. des fichiers.
$ umask # affiche la valeur telle que prédéfinie dans ~/.cshrc 77 # autrement dir 0077 $ umask 0027 $ umask 27 # autrement dit 0027
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 :
$ set history = 512
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 :
$ set savehist = 256
La commande history permet d'afficher les commandes dans l'ordre de leur mémorisation.
$ history ... 80 8:57 cp csh/Makefile Makefile.gen 81 9:03 more Makefile.gen 82 9:06 sed -e 's/SRCNAME=C-csh_n_tcsh/SRCNAME=/' Makefile.gen > 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 :
$ !84 which mkdir /bin/mkdir
Tableau 3. Quelques commandes de manipulation de l'historique
| 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, i.e. !-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.
alias h 'history -r \!* | less'
En csh la completion est activée par le positionnement de la variable d'environnement filec (c.f. « Section 1.5, « Variables prédéfinies et d'environnement » »). 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 :
_merge.pl check.pl fdate.sh mytest.pl _pidof.pl crlf.pl gen-meta-index.pl replace_header_html.pl _split.pl extract.pl idle.pl rotate.pl _test.pl extract_piste.sh logfile-1.2.pl rsync.pl bidir.pl fcomp.sh mylock.sh
Alors la séquence suivante :
$ ls l<ESC>
est résolue en (seule correspondance possible) :
$ ls logfile-1.2.pl
Tandis que la séquence ci-contre :
$ ls ext<ESC>
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 :
$ ls extract<CTRL>-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 *~.
$ set fignore = (.o .out *~)
Contexte utilisateur : 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 ~pa<ESC> $ 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 :
$ cd /home/cvsroot/C-network
et pour se rendre en
~/projets, taper :
$ cd ~/projets
Mais, cet utilisateur peut aussi se simplifier la vie en positionnant la variable cdpath, ainsi :
$ set cdpath = ( /home/cvsroot ~ )
Ainsi, il peut se contenter de :
taper dans le premier cas :
$ cd C-network /home/cvsroot/C-network
et dans le second :
$ cd projets ~/projets
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), i.e. 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
<?xml version='1.0' encoding='iso-8859-1' standalone='no'?> <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "/usr/local/share/xml/docbook/4.2/docbookx.dtd" [ <!ENTITY ccdil "ç"> <!ENTITY organ "Néotech III"> <!ENTITY unix "<productname>Unix</productname>"> <!ENTITY Unix "<emphasis>Unix</emphasis>"> <!ENTITY bsd "<emphasis>BSD</emphasis>"> <!ENTITY ie "<abbrev>i.e.</abbrev>"> <!ENTITY cf "<abbrev>c.f.</abbrev>"> <!ENTITY shell "<foreignphrase>shell</foreignphrase>"> ... encore plein de lignes...
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
| | 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, i.e. 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 :
Tableau 4. Sens des éléments 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 (c.f. 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 : i.e. 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, i.e. 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.
$ ps l UID PID PPID CPU PRI NI VSZ RSS MWCHAN STAT TT TIME COMMAND 2323 945 944 0 5 0 5248 3220 ttyin Is+ p0 0:00,03 tcsh 2323 4241 4240 0 20 0 5260 3340 pause Ss p1 0:00,08 tcsh 2323 4588 4241 0 96 0 4236 3460 select S p1 0:00,05 gv shells.pdf 2323 4592 4588 0 96 0 17572 14648 select I p1 0:03,41 gs -sDEVICE=x11 -dTextAlphaBits=4 -dGraphic 2323 4653 4241 0 96 0 1580 1060 - R+ p1 0:00,00 ps -l 2323 4370 4369 0 5 0 5248 3268 ttyin Is+ p2 0:00,03 tcsh
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], i.e. 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) :
$ fetchmail & [2] 20713
csh 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é :
last pid: 4689; load averages: 0.00, 0.00, 0.00 up 0+04:20:56 12:34:16 75 processes: 1 running, 74 sleeping CPU states: 1.9% user, 0.0% nice, 1.5% system, 0.0% interrupt, 96.6% idle Mem: 222M Active, 214M Inact, 107M Wired, 1556K Cache, 111M Buf, 445M Free Swap: 2048M Total, 2048M Free PID USERNAME THR PRI NICE SIZE RES STATE TIME WCPU COMMAND 4177 ikare 1 96 0 21764K 14140K select 0:05 0.49% xemacs-21.4.20 898 root 1 96 0 208M 114M select 36:45 0.39% Xorg 994 ikare 4 20 0 98472K 84764K kserel 2:30 0.00% firefox-bin 919 ikare 1 8 0 2904K 2012K nanslp 1:16 0.00% wmcube 918 ikare 1 96 0 2712K 1652K select 0:21 0.00% wmbattery 922 ikare 1 96 0 5884K 2856K select 0:12 0.00% wmusic 917 ikare 1 8 0 3012K 1932K nanslp 0:08 0.00% wmnd 921 ikare 1 8 0 2872K 1912K nanslp 0:06 0.00% wmwave 755 root 1 96 0 2944K 1660K select 0:04 0.00% hald-addon-storage 4592 ikare 1 96 0 18180K 15188K select 0:04 0.00% gs 925 ikare 1 8 0 4392K 2792K nanslp 0:03 0.00% mount.app 510 root 1 96 0 1456K 852K select 0:03 0.00% moused 746 haldaemon 1 96 0 5092K 3816K select 0:03 0.00% hald 920 ikare 1 8 0 2868K 1868K nanslp 0:02 0.00% wmitime 927 ikare 1 96 0 8224K 6544K select 0:01 0.00% fluxbox 924 ikare 1 96 0 3752K 3000K select 0:01 0.00% xscreensaver 4369 ikare 1 96 0 5656K 4704K select 0:01 0.00% aterm 369 _pflogd 1 -58 0 1748K 1360K bpf 0:00 0.00% pflogd
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 :
$ stty -a
speed 38400 baud; 50 rows; 132 columns;
lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl
-echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo
-extproc
iflags: -istrip icrnl -inlcr -igncr ixon -ixoff -ixany imaxbel -ignbrk
brkint -inpck ignpar -parmrk
oflags: opost onlcr -ocrnl -oxtabs -onocr -onlret
cflags: cread cs8 -parenb -parodd -hupcl -clocal -cstopb -crtscts
-dsrflow -dtrflow -mdmbuf
cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = <undef>;
eol2 = <undef>; 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, i.e. 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 :
$ kill -l HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ VTALRM PROF WINCH INFO USR1 USR2
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 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 :
$ sudu -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, i.e. 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 csh, c.f. « Section 1.5, « Variables prédéfinies et d'environnement » ») 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 (c.f. « Tableau 5, « référencement des jobs » ») récapitule les différentes manières de référencer un job.
Tableau 5. référencement des jobs
| 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 (c.f. « Tableau 6, « Commandes contrôlant les jobs » ») donne les commandes de contrôle d'un job.
Tableau 6. Commandes contrôlant les jobs
| 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 « Tableau 5, « référencement des jobs » ». Ainsi, la commande suivante met fin au job 1 :
$ kill -TERM %1
Important
En csh, 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).
$ limit # affichage des limites courantes cputime unlimited filesize unlimited datasize 262144 kbytes stacksize 262144 kbytes coredumpsize 0 kbytes memoryuse unlimited vmemoryuse unlimited descriptors 2048 memorylocked unlimited maxproc 1024 sbsize unlimited $ limit coredumpsize 1024 # augmenter la limite basse d'un fichier core à 1024k $ limit maxproc 2048 # augmenter le nb max de proc concurrents limit: maxproc: Can't set limit (Operation not permitted) $ limit maxproc 512 # augmenter le nb max de proc concurrents (lim. cour.) $ limit -h maxproc 784 # augmenter le nb max de proc concurrents (lim. hautes) $ limit # affichage des limites courantes cputime unlimited filesize unlimited datasize 262144 kbytes stacksize 262144 kbytes coredumpsize 1024 kbytes memoryuse unlimited vmemoryuse unlimited descriptors 2048 memorylocked unlimited maxproc 512 sbsize unlimited $limit -h # affichage des limites hautes cputime unlimited filesize unlimited datasize 262144 kbytes stacksize 262144 kbytes coredumpsize unlimited memoryuse unlimited vmemoryuse unlimited descriptors 2048 memorylocked unlimited maxproc 784 sbsize unlimited
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.
Tableau 7. Redirections
| 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 (i.e. sans le !, c.f. « Tableau 7, « Redirections » »).
EXEMPLES :
$ cat > 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 :
<commandA> | <commandB>
Exemple 4. Utilisation du mécanisme de pipeline
$ ls -l | sort -k 5n
La sortie de la commande ls -l est redirigée vers l'entrée de la commande sort -k 5n.
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).
<commandA> |& <commandB>
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