SO105 - La Ligne de Commande

Un shell est un interpréteur de commandes ou en anglais un Command Line Interpreter (C.L.I). Il est utilisé comme interface pour donner des instructions ou commandes au système d'exploitation.

Le mot shell est générique. Il existe de nombreux shells dans le monde Unix, par exemple :

Cette unité concerne l'utilisation du shell ksh sous Unix. Cependant, il peut aussi être utile aux utilisateurs de bash sous UNIX car les commandes sont pratiquement identiques.

Le shell /bin/ksh permet de:

• Rappeler des commandes
• Générer la fin de noms de fichiers
• Utiliser des alias
• Utiliser les variables tableaux
• Utiliser les variables numériques et l'arithmétique du langage C
• Gérer des chaines de caractères
• Utiliser les fonctions

Une commande commence toujours par un mot clef. Ce mot clef est interpréter par le shell selon le type de commande et dans l'ordre qui suit :

1. Les alias
2. Les fonctions
3. Les commandes internes au shell
4. Les commandes externes au shell

Le shell par défaut de root sous Solaris est /bin/sh.

Le shell des utilisateurs est défini par root dans le fichier /etc/passwd :

# cat /etc/passwd
root:x:0:0:Super-User:/:/sbin/sh
daemon:x:1:1::/:
bin:x:2:2::/usr/bin:
sys:x:3:3::/:
adm:x:4:4:Admin:/var/adm:
lp:x:71:8:Line Printer Admin:/usr/spool/lp:
uucp:x:5:5:uucp Admin:/usr/lib/uucp:
nuucp:x:9:9:uucp Admin:/var/spool/uucppublic:/usr/lib/uucp/uucico
smmsp:x:25:25:SendMail Message Submission Program:/:
listen:x:37:4:Network Admin:/usr/net/nls:
gdm:x:50:50:GDM Reserved UID:/:
webservd:x:80:80:WebServer Reserved UID:/:
postgres:x:90:90:PostgreSQL Reserved UID:/:/usr/bin/pfksh
svctag:x:95:12:Service Tag UID:/:
nobody:x:60001:60001:NFS Anonymous Access User:/:
noaccess:x:60002:60002:No Access User:/:
nobody4:x:65534:65534:SunOS 4.x NFS Anonymous Access User:/:
test:x:100:1:Test:/export/home/test:/bin/ksh

Devenez maintenant l'utilisateur test grâce à la commande su - :

# su - test
Sun Microsystems Inc.   SunOS 5.10      Generic January 2005
$

Vérifiez que le shell de l'utilisateur test soit bien ksh grâce à la consultation de la valeur de la variable système SHELL :

$ echo $SHELL
/bin/ksh

Il convient maintenant de modifier le shell de test en bash :

$ which bash
/usr/bin/bash

passez en tant que root grâce à la commande exit puis éditez le fichier /etc/passwd :

test:x:101:1:Test:/export/home/test:/usr/bin/bash

Ensuite connectez-vous de nouveau en tant que l'utilisateur test et utilisez la commande echo pour visualiser le contenu de la variable système SHELL :

# su - test
Sun Microsystems Inc.   SunOS 5.10      Generic January 2005
-bash-3.00$ echo $SHELL
/usr/bin/bash

Une commande tapée dans un CLI commence toujours par un mot clef. Ce mot clef est interprétée par le shell selon le type de commande et dans l'ordre qui suit :

1. Les alias
2. Les fonctions
3. Les commandes internes au shell
4. Les commandes externes au shell

La suite de ce cours concerne l'utilisation du shell ksh sous Solaris. Le shell ksh permet de:

• Rappeler des commandes
• Générer la fin de noms de fichiers
• Utiliser des alias
• Utiliser les variables tableaux
• Utiliser les variables numériques et l'arithmétique du langage C
• Gérer des chaînes de caractères
• Utiliser les fonctions

Defenissez le shell courant de root en tant que /bin/ksh :

# /bin/ksh
#

Les commandes internes au shell sont des commandes telles cd. Pour vérifier le type de commande, il faut utiliser la commande type en tant que root :

# type cd
cd est une commande prédéfinie du shell

Les commandes externes au shell sont des binaires exécutables ou des scripts, généralement situés dans /usr/sbin, /usr/bin, /usr/openwin/bin ou /usr/ucb :

# type ifconfig
ifconfig est /usr/sbin/ifconfig

Les alias sont des noms permettant de désigner une commande ou une suite de commandes et ne sont spécifiques qu'au shell qui les a créés ainsi qu'à l'environnement de l'utilisateur :

# type stop
stop est un alias exporté pour kill -STOP

ou

# su - test
Sun Microsystems Inc.   SunOS 5.10      Generic January 2005
$ type ls
ls est un alias suivi pour /usr/bin/ls

La liste des alias définis peut être visualisée en utilisant la commande alias :

$ alias
autoload='typeset -fu'
command='command '
functions='typeset -f'
history='fc -l'
integer='typeset -i'
local=typeset
ls=/usr/bin/ls
nohup='nohup '
r='fc -e -'
stop='kill -STOP'
suspend='kill -STOP $$'

Un alias se définit en utilisant de nouveau la commande alias :

$ alias dir='ls -l'
$ alias
autoload='typeset -fu'
command='command '
dir='ls -l'
functions='typeset -f'
history='fc -l'
integer='typeset -i'
local=typeset
ls=/usr/bin/ls
nohup='nohup '
r='fc -e -'
stop='kill -STOP'
suspend='kill -STOP $$'
$ dir
total 6
-rw-r--r--   1 test     other        136 août 15 10:19 local.cshrc
-rw-r--r--   1 test     other        157 août 15 10:19 local.login
-rw-r--r--   1 test     other        174 août 15 10:19 local.profile

Pour supprimer un alias, il convient d'utiliser la commande unalias :

$ unalias dir
$ alias
autoload='typeset -fu'
cat=/usr/bin/cat
command='command '
functions='typeset -f'
history='fc -l'
integer='typeset -i'
local=typeset
ls=/usr/bin/ls
nohup='nohup '
r='fc -e -'
stop='kill -STOP'
suspend='kill -STOP $$'

Pour forcer l'exécution d'une commande et non l'alias il faut faire précéder la commande par le caractère \ :

$ alias ls='ls -l'
$ ls
total 6
-rw-r--r--   1 test     other        136 août 15 10:19 local.cshrc
-rw-r--r--   1 test     other        157 août 15 10:19 local.login
-rw-r--r--   1 test     other        174 août 15 10:19 local.profile
$ \ls
local.cshrc    local.login    local.profile

Le prompt d'un utilisateur dépend de son statut :

• $ pour un utilisateur normal
• # pour root

Le shell ksh permet le rappel des dernières commandes saisies. Afin de connaître la liste des commandes mémorisées, utilisez la commande history en tant que l'utilisateur test :

$ history
5       exit
6       type ls
7       alias
8       alias dir='ls -l'
9       alias
10      cat /etc/shells
11      dir
12      \dir
13      unalias dir
14      alias
15      alias ls='ls -l'
16      ls
17      \ls
18      which chsh
19      ls -a
20      history

Rappelez-vous que la commande history est un alias :

$ alias
...
history='fc -l'
...

En réalité donc c'est la commande fc qui est appelée.

L'historique des commandes est en mode emacs par défaut. Afin de pouvoir rappeler les dernières commandes saisies, il convient de passer en mode emacs :

$ set -o emacs

Le rappel de la dernière commande se fait en utilisant les touches [CTRL]-[P] et le rappel de la commande suivante se fait en utilisant les touches [CTRL]-[N] :

Le paramétrage de la fonction du rappel des commandes est fait en définissant des variables système.

Afin de faciliter la définition de ces variables, créez le fichier /etc/kshrc en tant que root :

#
# This file is the common Environment setup for Korn Shell
#
HISTSIZE=256
HISTFILE=$HOME/.sh_history
export HISTFILE HISTSIZE
set -o emacs

Vous noterez que dans ce fichier, la valeur de HISTSIZE est de 256. Ceci implique que les dernières 256 commandes sont mémorisées.

Devenez maintenant l'utilisateur standard test :

# su - test
Sun Microsystems Inc.   SunOS 5.10      Generic January 2005
$

Les commandes mémorisées sont stockées dans le fichier $HOME/.sh_history ou $HOME indique le répertoire personnel de l'utilisateur concerné :

$ cat $HOME/.sh_history

echo $SHELL
whereis bash
which bash
exit
exit
type ls
alias
alias dir='ls -l'
alias
cat /etc/shells
dir
\dir
unalias dir
alias
alias ls='ls -l'
ls
\ls
ls -a
history
alias
set -o emacs
exit
cat $HOME/.sh_history

Vous pouvez rappeler une commande spécifique de l'historique en utilisant la commande fc -e - suivi du numéro de la commande à rappeler :

$ history
...
52      ls
53      pwd
54      vmstat
55      df
56      history
$ fc -e - 52
ls
local.cshrc    local.login    local.profile

Afin de faire appel à au fichier /etc/kshrc, éditez maintenant le fichier /etc/profile :

$ exit
# vi /etc/profile

en y ajoutant les lignes suivantes :

ENV=/etc/kshrc
export ENV

Vous obtiendrez une fenêtre similaire à celle-ci :

#ident  "@(#)profile    1.19    01/03/13 SMI"   /* SVr4.0 1.3   */

# The profile that all logins get before using their own .profile.

trap ""  2 3
export LOGNAME PATH

ENV=/etc/kshrc
export ENV

if [ "$TERM" = "" ]
then
        if /bin/i386
        then
                TERM=sun-color
        else
                TERM=sun
        fi
        export TERM
fi

#       Login and -su shells get /etc/profile services.
#       -rsh is given its environment in its .profile.

Connectez-vous de nouveau en tant que test :

# su - test
Sun Microsystems Inc.   SunOS 5.10      Generic January 2005

Vérifiez que vous pouvez rappeler les dernières commandes dans votre console.

Le shell ksh permet la génération des fins de noms de fichiers. Celle-ci est accomplie grâce à l'utilisation de la touche [echap]. Dans l'exemple qui suit, la commande saisie est :

$ ls [echap] [echap]

Vous obtiendrez :

$ ls local.

Vous noterez que le shell propose local.. En effet, sans plus d'information, le shell ne sait pas quel fichier parmi les trois présents doit être ouvert :

$ ls | grep local.
local.cshrc
local.login
local.profile

Par contre si vous ajoutez la lettre c :

$ ls local.c [echap] [echap]

vous noterez que le nom du fichier est complété automatiquement. Ceci est du au fait qu'il n'existe qu'un seul élément dans le répertoire commençant par la chaîne local.c :

$ ls local.cshrc

Lors de l'utilisation du shell, nous avons souvent besoin d'exécuter une commande sur plusieurs fichiers au lieu de les traiter individuellement. A cette fin nous pouvons utiliser les caractères spéciaux.

Dans votre répertoire individuel, créez un répertoire formation. Ensuite créez dans ce répertoire 5 fichiers nommés respectivement f1, f2, f3, f4 et f5 :

$ pwd
/export/home/test
$ mkdir formation
$ cd formation
$ touch f1 f2 f3 f4 f5
$ ls -l
total 0
-rw-r--r--   1 test     other          0 août 15 16:00 f1
-rw-r--r--   1 test     other          0 août 15 16:00 f2
-rw-r--r--   1 test     other          0 août 15 16:00 f3
-rw-r--r--   1 test     other          0 août 15 16:00 f4
-rw-r--r--   1 test     other          0 août 15 16:00 f5

Afin de démontrer l'utilisation du caractère spécial *, saisissez la commande suivante :

$ echo f*
f1 f2 f3 f4 f5

Créez maintenant les fichiers f52 et f62 :

$ touch f52 f62

Saisissez ensuite la commande suivante :

$ echo f?2
f52 f62

L'utilisation peut prendre plusieurs formes différentes :

Afin de démontrer l'utilisation des caractères [ et ], créez le fichier a100 :

$ touch a100

Ensuite saisissez les commandes suivantes et notez le résultat :

$ echo [a-f]*
a100 f1 f2 f3 f4 f5 f52 f62
$ echo [af]*
a100 f1 f2 f3 f4 f5 f52 f62

$ echo [!a]*
f1 f2 f3 f4 f5 f52 f62

$ echo [a-b]*
a100

$ echo [a-f]
[a-f]

Créez les fichiers f, f.txt, f123.txt, f123123.txt, f123123123.txt :

$ touch f f.txt f123.txt f123123.txt f123123123.txt

Saisissez la commande suivante :

$ ls f?(123).txt
f.txt     f123.txt

Saisissez la commande suivante :

$ ls f*(123).txt
f.txt           f123.txt        f123123.txt     f123123123.txt

Saisissez la commande suivante :

$ ls f+(123).txt
f123.txt        f123123.txt     f123123123.txt

Saisissez la commande suivante :

$ ls f@(123).txt
f123.txt

Saisissez la commande suivante :

$ ls f!(123).txt
f.txt           f123123.txt     f123123123.txt

Afin d'utiliser un caractère spécial dans un contexte littéral, il faut utiliser un caractère d'échappement. Il existe trois caractères d'échappement :

Afin d'illustrer l'utilisation des caractères d'échappement, considérons la commande suivante :

$ echo * est un caractère spécial [Entrée]

Lors de la saisie de cette commande dans votre répertoire formation, vous obtiendrez une fenêtre similaire à celle-ci :

$ echo * est un caractère spécial
a100 f1 f2 f3 f4 f5 f52 f62 est un caractère spécial

Vous noterez que le caractère spécial * a bien été interprété par le shell.

Afin de protéger le caractère *, nous devons utiliser un caractère d'échappement. Commençons par l'utilisation du caractère \ :

$ echo \* est un caractère spécial
* est un caractère spécial

Vous noterez que le caractère spécial * n'a pas été interprété par le shell.

Le même résultat peut être obtenu en utilisant ainsi :

$ echo "* est un caractère spécial"
* est un caractère spécial
$ echo '* est un caractère spécial'
* est un caractère spécial

Chaque commande retourne un code à la fin de son exécution. La variable spéciale $? sert à stocker le code retour de la dernière commande exécutée.

Par exemple :

$ cd ..
$ mkdir codes
$ echo $?
0
$ touch codes/retour
$ rmdir codes
rmdir: échec de suppression de « codes »: Le dossier n'est pas vide
$ echo $?
2

Dans cette exemple la création du répertoire codes s'est bien déroulée. Le code retour stocké dans la variable $? est un zéro.

La suppression du répertoire a rencontré une erreur car codes contenait le fichier retour. Le code retour stocké dans la variable $? est un deux.

Si le code retour est zéro la dernière commande s'est déroulée sans erreur.

Si le code retour est autre que zéro la dernière commande s'est déroulée avec une erreur.

Votre dialogue avec le système Solaris utilise des canaux d’entrée et de sortie. On appelle le clavier, le canal d’entrée standard et l’écran, le canal de sortie standard :

;#;;#;

Autrement dit, en tapant une commande sur le clavier, vous voyez le résultat de cette commande à l’écran.

Parfois, cependant il est utile de re-diriger le canal de sortie standard vers un fichier. De cette façon, le résultat d’une commande telle free peut être stocké dans un fichier pour une consultation ultérieure :

;#;;#;

Cet effet est obtenu en utilisant une redirection :

$ vmstat > fichier [Entrée]

Si le fichier cible n’existe pas, il est créé et son contenu sera le résultat de la commande vmstat. Par contre si le fichier existe déjà, il sera écrasé.

Pour ajouter des données supplémentaires au même fichier cible, il faut utiliser une double redirection :

$ date >> fichier [Entrée]

De cette façon, la date du jour sera rajoutée à la fin de votre fichier après les informations de la commande free.

Pour visualiser le contenu du fichier fichier nous utilisons la commande cat :

$ vmstat > fichier
$ date >> fichier
$ cat fichier
 kthr      memory            page            disk          faults      cpu
 r b w   swap  free  re  mf pi po fr de sr cd s0 -- --   in   sy   cs us sy id
 0 0 0 907680 469372 139 1580 8 0  0  0 14  3 -1  0  0  454 2712  367  2  4 94
mercredi 15 août 2012 17 h 33 CEST

Les canaux d’entrées et de sorties sont numérotés :

• 0 = Le Canal d’entrée Standard
• 1 = Le Canal de Sortie Standard
• 2 = Le Canal d’erreur

La commande suivante créera un fichier nommé erreurlog qui contient les messages d’erreur de l’exécution de la commande rmdir :

$ rmdir formation/ 2> erreurlog
$ cat erreurlog
rmdir : répertoire "formation/" : Répertoire non vide

En effet l'erreur est générée parce que le répertoire formation n'est pas vide.

Nous pouvons également réunir des canaux. Pour mettre en application ceci, il faut comprendre que le shell traite les commandes de gauche à droite.

Dans l’exemple suivant, nous réunissons le canal de sortie et le canal d’erreurs :

$ vmstat > nom_du_fichier 2>&1

La syntaxe 2>&1 envoie la sortie du canal 2 au même endroit que le canal 1, à savoir le fichier dénommé fichier.

Il est possible de modifier le canal d'entrée standard afin de lire des informations à partir d’un fichier. Dans ce cas la redirection est obtenue en utilisant le caractère < :

$ wc -w < erreurlog
       8

Il est aussi possible de relier des commandes avec un tube | .

Dans ce cas, le canal de sortie de la commande à gauche du tube est envoyé au canal d’entrée de la commande à droite du tube :

$ ls | wc -w
       6

Rappelez-vous que la sortie standard ne peut être redirigée que dans une seule direction. Afin de pouvoir rediriger la sortie standard vers un fichier et le visualiser à l'écran, nous devons utiliser la commande tee avec un pipe :

$ date | tee fichier1
mercredi 15 août 2012 17 h 31 CEST
$ cat fichier1
mercredi 15 août 2012 17 h 31 CEST

Cette même technique nous permet de créer deux fichiers :

$ date | tee fichier1 > fichier2
$ cat fichier1
mercredi 15 août 2012 17 h 31 CEST
$ cat fichier2
mercredi 15 août 2012 17 h 31 CEST

Il est parfois intéressant, notamment dans les scripts, de remplacer une commande par la valeur de sa sortie. Afin d'illustrer ce point, considérons la commande suivante :

$echo $(date) [Entrée]

$ echo date
date
$ echo $(date)
mercredi 15 août 2012 17 h 22 CEST
$ echo `date`
mercredi 15 août 2012 17 h 22 CEST

Il est possible de regrouper des commandes à l’aide d’un sous-shell :

$ (ls -l; ps; who) > liste
$ cat liste
total 10
drwxr-xr-x   2 test     other        512 août 15 16:10 codes
drwxr-xr-x   2 test     other        512 août 15 16:03 formation
-rw-r--r--   1 test     other          0 août 15 17:25 liste
-rw-r--r--   1 test     other        136 août 15 10:19 local.cshrc
-rw-r--r--   1 test     other        157 août 15 10:19 local.login
-rw-r--r--   1 test     other        174 août 15 10:19 local.profile
   PID TTY         TIME CMD
  4356 pts/3       0:00 ksh
  4358 pts/3       0:00 ps
 23399 pts/3       0:00 ksh
root       console      août 12 10:48   (:0)
root       pts/3        août 15 15:37   (:0.0)

Cet exemple envoie le résultat des trois commandes vers le fichier liste en les traitant en sous-tâches (en tâches de fond).

Rappelez-vous que chaque commande transmet la façon dont elle a été exécutée (Code Retour). Dans le cas d’un traitement sans erreurs, la valeur du Code retour est 0, sinon elle est autre que 0.

De cette façon, en utilisant les caractères && ou ||, les commandes peuvent être chainées en fonction du Code Retour de la commande précédente.

&& est utilisé afin de s’assurer que la deuxième commande s’exécute dans le cas où la valeur du Code Retour de la première commande est 0, autrement dit qu’il n’y a pas eu d’erreurs.

Le syntaxe de cette commande est :

Commande1 && Commande2

Par exemple :

$ ls && pwd
codes          liste          local.login
formation      local.cshrc    local.profile
/export/home/test

et :

$ rmdir formation && pwd
rmdir : répertoire "formation" : Répertoire non vide

Dans ce cas, Commande 2 est exécutée uniquement dans le cas où Commande1 s’est exécuté sans erreur

Ou :

Commande1 || Commande2

Dans ce cas, Commande2 est exécuté si Commande1 a rencontré une erreur.

Par exemple :

$ ls || pwd
codes          liste          local.login
formation      local.cshrc    local.profile

et :

$ rmdir formation || pwd
rmdir : répertoire "formation" : Répertoire non vide
/export/home/test

Une variable du shell peut être affichée grâce à la commande :

$echo $nom_de_la_variable [Entrée]

L'Internationalisation, aussi appelé i18n car il y a 18 lettres entre la lettre I et la lettre n dans le mot Internationalization, consiste à adapter un logiciel aux paramètres variant d'une région à l'autre :

• longueur des mots,
• accents,
• écriture de gauche à droite ou de droite à gauche,
• unité monétaire,
• styles typographiques et modèles rédactionnels,
• unités de mesures,
• affichage des dates et des heures,
• formats d'impression,
• format du clavier,
• etc …

Le Régionalisation, aussi appelé i10n car il y a 10 lettres entre la lettre L et la lettre n du mot Localisation, consiste à modifier l'internalisation en fonction d'une région spécifique.

Le code pays complet prend la forme suivante : langue-PAYS.jeu_de_caractères. Par exemple, pour la langue française les valeurs de langue-PAYS sont :

• fr-BE = la Belgique francophone,
• fr-CA = le Québec,
• fr-FR = la France,
• fr-LU = le Luxembourg,
• fr-MC = Monaco,
• fr-CH = la Suisse francophone.

Les variables système les plus importants contenant les informations concernant le régionalisation sont :

Par exemple :

$ echo $LC_ALL

$ echo $LC_CTYPE
fr_FR.ISO8859-1
$ echo $LANG
fr_FR.ISO8859-1

Pour visualiser les options du shell ksh, il convient d'utiliser la commande set :

$ set -o
Paramétrage courant des options
allexport        off
bgnice           on
emacs            on
errexit          off
gmacs            off
ignoreeof        off
interactive      on
keyword          off
markdirs         off
monitor          on
noexec           off
noclobber        off
noglob           off
nolog            off
notify           off
nounset          off
privileged       off
restricted       off
trackall         off
verbose          off
vi               off
viraw            off
xtrace           off

Pour activer une option il convient de nouveau à utiliser la commande set :

$ set -o allexport
$ set -o
Paramétrage courant des options
allexport        on
bgnice           on
emacs            on
errexit          off
gmacs            off
ignoreeof        off
interactive      on
keyword          off
markdirs         off
monitor          on
noexec           off
noclobber        off
noglob           off
nolog            off
notify           off
nounset          off
privileged       off
restricted       off
trackall         off
verbose          off
vi               off
viraw            off
xtrace           off

Notez que l'option allexport a été activée.

Pour désactiver une option, on utilise la commande set avec l'option +o :

$ set +o allexport
$ set -o
Paramétrage courant des options
allexport        off
bgnice           on
emacs            on
errexit          off
gmacs            off
ignoreeof        off
interactive      on
keyword          off
markdirs         off
monitor          on
noexec           off
noclobber        off
noglob           off
nolog            off
notify           off
nounset          off
privileged       off
restricted       off
trackall         off
verbose          off
vi               off
viraw            off
xtrace           off

Parmi les options, voici la description des plus intéressantes :

$ set -o noclobber
$ pwd > file
$ pwd > file
ksh: file: ce fichier existe déjà
$ pwd >| file
$ set +o noclobber

$ set -o noglob
$ echo *
*
$ set +o noglob
$ echo *
core Desktop Documents erreurlog fichier1 fichier2 file formation kshrc kshrc1 liste local.cshrc local.login local.profile nom_du_fichier

$ set -o nounset
$ echo $FENESTROS
ksh: FENESTROS: paramètre non défini
$ set +o nounset
$ echo $FENESTROS

$

$ set -o verbose
$ echo fenestros
echo fenestros
fenestros
$ set +o verbose
set +o verbose
$ echo fenestros
fenestros

Le but de la suite de cette unité est de vous amener au point où vous êtes capable de comprendre et de déchiffrer les scripts, notamment les scripts de démarrage ainsi que les scripts de contrôle des services.

Écrire des scripts compliqués est en dehors de la portée de cette unité car il nécessite une approche programmation qui ne peut être adressée que lors d'une formation dédiée à l'écriture des scripts.

Un script shell est un fichier dont le contenu est lu en entrée standard par le shell. Le contenu du fichier est lu et exécuté d'une manière séquentielle. Afin qu'un script soit exécuté, il suffit qu'il puisse être lu au quel cas le script est exécuté par un shell fils soit en l'appelant en argument à l'appel du shell :

/usr/bin/ksh monscript

soit en redirigeant son entrée standard :

/usr/bin/ksh < monscript

Dans le cas où le droit d'exécution est positionné sur le fichier script et à condition que celui-ci se trouve dans un répertoire spécifié dans le PATH de l'utilisateur qui le lance, le script peut être lancé en l'appelant simplement par son nom :

monscript

Dans le cas où le script doit être exécuté par le shell courant, dans les mêmes conditions que l'exemple précédent, mais qu'il se trouve dans un répertoire autre qu'un des répertoires spécifiés dans le PATH de l'utilisateur qui le lance, il convient de naviguer au répertoire concerné et de lancer la commande suivante :

./monscript

Dans le cas où le script doit être exécuté par le shell courant, dans les mêmes conditions que l'exemple précédent, et non par un shell fils, il convient de le lancer ainsi :

. monscript

Dans un script il est fortement conseillé d'inclure des commentaires. Les commentaires permettent à d'autres personnes de comprendre le script. Toute ligne de commentaire commence avec le caractère #.

Il existe aussi un pseudo commentaire qui est placé au début du script. Ce pseudo commentaire permet de stipuler quel shell doit être utilisé pour l'exécution du script. L'exécution du script est ainsi rendu indépendant du shell de l'utilisateur qui le lance. Le pseudo commentaire commence avec les caractères #!. Chaque script commence donc par une ligne similaire à celle-ci :

#!/bin/sh

Pour illustrer l'écriture et l'exécution d'un script, créez le fichier monscript avec vi :

$ vi monscript [Entrée]

Editez votre fichier ainsi :

#debut du fichier monscript
pwd
ls
#fin du fichier monscript

Sauvegardez votre fichier et sortez du programme vi. Lancez ensuite votre script en passant le nom du fichier en argument à /bin/ksh :

$ /usr/bin/ksh monscript
/export/home/test
codes          fichier1       liste          local.profile
erreurlog      fichier2       local.cshrc    monscript
fichier        formation      local.login

Lancez ensuite le script en redirigeant son entrée standard :

$ /usr/bin/ksh < monscript
/export/home/test
codes          fichier1       liste          local.profile
erreurlog      fichier2       local.cshrc    monscript
fichier        formation      local.login

Pour lancer le script en l'appelant simplement par son nom, son chemin doit être inclus dans votre PATH.

Saisissez les commandes suivantes :

$ pwd
/export/home/test
$ mkdir bin
$ PATH=$PATH:$HOME/bin
$ export PATH
$ echo $PATH
/usr/bin::/export/home/test/bin

Vous constaterez que le répertoire /export/home/test/bin a été rajouté à votre PATH grâce à la ligne PATH=$PATH:$HOME/bin. Déplacez votre script dans ce répertoire, vérifiez les permissions de votre script, rendez-le exécutable pour votre utilisateur et vérifiez qu'il est bien exécutable:

$ mv monscript ~/bin
$ cd ~/bin
$ chmod u+x monscript
$ ls -l
total 2
-rwxr--r--   1 test     other         61 août 15 17:45 monscript

Positionnez-vous dans le répertoire /tmp et exécutez maintenant votre script en l'appelant par son nom :

$ cd /tmp
$ monscript
/tmp
breg_business_logic_20120812104901282.log
breg_business_logic_20120812104901282.log.lck
hsperfdata_noaccess
hsperfdata_root
ogl_select270
rootswup.trc
sh6826.1

Dans les trois cas précédents, le script a été exécuté dans un shell fils. Pour l'exécuter dans le shell en cours, rappelez-vous que la commande est :

$ . monscript
/tmp
breg_business_logic_20120812104901282.log
breg_business_logic_20120812104901282.log.lck
hsperfdata_noaccess
hsperfdata_root
ogl_select270
rootswup.trc
sh6826.1

La commande read lit son entrée standard et affecte les mots saisis dans la ou les variable(s) passée(s) en argument :

# read var1 var2
fenestros edu
# echo $var1
fenestros
# echo $var2
edu

La séparation entre le contenu des variables est l'espace. Par conséquent il est intéressant de noter les exmples suivants :

# read var1 var2 var3 var4
fenestros edu est super!
# echo $var1
fenestros
# echo $var2
edu
# echo $var3
est
# echo $var4
super!

# read var1 var2
fenestros edu est super!
# echo $var1
fenestros
# echo $var2
edu est super!

La commande read renvoie un code de retour de 0 dans le cas où elle ne reçoit pas l'information fin de fichier matérialisée par les touches Ctrl+D :

# read var
fenestros
# echo $?
0
# echo $var
fenestros

Le contenu de la variable var peut être vide et la valeur du code de retour 0 grâce à l'utilisation de la touche Entrée :

# read var

# echo $?
0
# echo $var

#

Le contenu de la variable var peut être vide et la valeur du code de retour autre que 0 grâce à l'utilisation des touches Ctrl+D :

# read var
^D
# echo $?
1
# echo $var

#

La variable IFS contient par défaut les caractères Espace, Tab et Entrée :

# echo "$IFS" | od -c
0000000      \t  \n  \n
0000004

La valeur de cette variable définit donc le séparateur de mots lors de la saisie des contenus des variables avec la commande read. La valeur de la variable IFS peut être modifiée :

# OLDIFS="$IFS"
# echo "$OLDIFS" | od -c
0000000      \t  \n  \n
0000004
# IFS=":"
# echo "$IFS" | od -c
0000000   :  \n
0000002

De cette façon l'espace redevient un caractère normal :

# read var1 var2 var3
fenestros:edu est:super!
# echo $var1
fenestros
# echo $var2
edu est
# echo $var3
super!

La commande test peut être utilisée avec deux syntaxes :

test expression

ou

[EspaceexpressionEspace]

Testez si le fichier a100 est un fichier ordinaire :

# cd formation
# test -f a100
# echo $?
0
# [ -f a100 ]
# echo $?
0

Testez si le fichier a101 existe :

# [ -f a101 ]
# echo $?
1

Testez si /export/home/test/formation est un répertoire :

# [ -d /export/home/test/formation ]
# echo $?
0

Testez si les deux chaînes sont égales :

# chaine1="root"
# chaine2="fenestros"
# [ "chaine1" = "chaine2" ]
# echo $?
1

Testez si la chaîne1 n'a pas de longueur 0 :

# [ -n "chaine1" ]
# echo $?
0

Testez si la chaîne1 a une longueur de 0 :

# [ -z "chaine1" ]
# echo $?
1

Comparez les deux nombres nombre1 et nombre2 :

# read nombre1
35
# read nombre2
21
# [ $nombre1 -lt $nombre2 ]
# echo $?
1
# [ $nombre2 -lt $nombre1 ]
# echo $?
0
# [ $nombre2 -eq $nombre1 ]
# echo $?
1

Testez si $fichier n'est pas un répertoire :

# fichier=a100
# [ ! -d $fichier ]
# echo $?
0

Testez si $repertoire est un répertoire et si l'utilisateur à le droit de le traverser :

# repertoire=/usr
# [ -d $repertoire -a -x $repertoire ]
# echo $?
0

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

# [ -w a100 -a \( -d /usr -o -d /tmp \) ]
# echo $?
1
# cd formation
# [ -w a100 -a \( -d /usr -o -d /tmp \) ]
# echo $?
0

# [ -o allexport ]
# echo $?
1
# [ -o interactive-comments ]
# echo $?
0

La commande [[EspaceexpressionEspace]] est une amélioration de la commande test. Les opérateurs de la commande test sont compatibles avec la commande [[ expression ]] sauf -a et -o qui sont remplacés par && et || respectivement :

D'autres opérateurs ont été ajoutés :

Testez si l'utilisateur peut écrire dans le fichier a100 et /usr est un répertoire ou /tmp est un répertoire :

# [[ -w a100 && ( -d /usr || -d /tmp ) ]]
# echo $?
0

Exemples :

# [[ -d /tmp ]] && echo "Répertoire tmp existe"
Répertoire tmp existe
# [[ -d /tmp ]] || echo "Répertoire tmp existe"

#

La commande expr prend la forme :

expr Espace nombre1 Espace opérateur Espace nombre2 Entrée

ou

expr Tab nombre1 Tab opérateur Tab nombre2 Entrée

ou

expr Espace chaîne Espace : Espace expression_régulière Entrée

ou

expr Tab chaîne Tab : Tab expression_régulière Entrée

Ajoutez 2 à la valeur de $x :

$ x=2
$ expr $x + 2
4

Si les espaces sont retirés, le résultat est tout autre :

$ expr $x+2
2+2

Les opérateurs doivent être protégés :

$ expr $x * 2
expr: syntax error
$ expr $x \* 2
4

Mettez le résultat d'un calcul dans un variable :

$ resultat=`expr $x + 10`
$ echo $resultat
12

La commande let est l'équivalent de la commande ((expression)). La commande ((expression)) est une amélioration de la commande expr :

• plus grand nombre d'opérateurs
• pas besoin d'espaces ou de tabulations entre les arguments
• pas besoin de préfixer les variables d'un $
• les caractères spéciaux du shell n'ont pas besoin d'être protégés
• les affectations se font dans la commande
• exécution plus rapide

$ x=2
$ ((x=$x+10))
$ echo $x
12
$ ((x=x+20))
$ echo $x
32

La syntaxe de la commande If est la suivante :

if condition
then
    commande(s)
else 
    commande(s)
fi

ou :

if condition
then
    commande(s)
    commande(s)
fi

ou encore :

if condition
then
     commande(s)
elif condition
then
     commande(s)
elif condition
then
     commande(s)
else 
    commande(s)

fi

La syntaxe de la commande case est la suivante :

case $variable in
modele1) commande
   ...
   ;;
modele2) commande
   ...
   ;;
modele3 | modele4 | modele5 ) commande
   ...
   ;;
esac

La syntaxe de la commande for est la suivante :

for variable in liste_variables
do
    commande(s)
done

La syntaxe de la commande while est la suivante :

while condition
do
    commande(s)
done

Lors de chaque connexion au système, un script de démarrage est exécuté automatiquement. Ce script se trouve dans le répertoire personnel de l'utilisateur et porte un nom différent selon le shell utilisé:

• .profile pour le ksh
• .bash_profile pour le bash

Par exemple :

$ ls -a
total 16
drwxr-xr-x   2 test     other        512 août 15 11:50 .
drwxr-xr-x   4 root     root         512 août 15 10:19 ..
-rw-------   1 test     other         17 août 15 11:50 .bash_history
-rw-r--r--   1 test     other        144 août 15 10:19 .profile
-rw-------   1 test     other        200 août 15 12:16 .sh_history
-rw-r--r--   1 test     other        136 août 15 10:19 local.cshrc
-rw-r--r--   1 test     other        157 août 15 10:19 local.login
-rw-r--r--   1 test     other        174 août 15 10:19 local.profile

L'étude du fichier .profile pour votre utilisateur démontrera un fichier similaire à celui-ci :

$ cat .profile
#       This is the default standard profile provided to a user.
#       They are expected to edit it to meet their own needs.

MAIL=/usr/mail/${LOGNAME:?}

Dans ce fichier nous pouvons noter la définition de la variable MAIL.

<html> <center> Copyright © 2011-2018 I2TCH LIMITED.<br><br> </center> </html>