Petit Guide Unix

3. Notion de Session

3.1. Login et Interprète de Commandes

Une session UNIX commence à partir de la connexion à l'ordinateur (login) et se poursuit jusqu'à la déconnexion (commande unix logout (ou ^D)).

Une session UNIX est gérée par un interprète de commandes dit shell, (qui veut dire coquille, i.e. dans ce cas, la couche externe d'un OS et qui constitue l'interface utilisateur). L'interprète de commandes (on dira shell dorénavant) est un programme qui lit une commande utilisateur et qui l'exécute. C'est la caractéristique d'un système d'exploitation temps partagé. Il existe généralement trois shells sous UNIX.

Le Bourne Shell (programme /bin/sh), qui est le shell original d'UNIX.

Prompt $

Le Cshell (programme /bin/csh), qui est un shell développé par Berkeley et qui offre plus de fonctionnalités. Il s'appelle ainsi, à cause de la syntaxe de son langage qui est C_like.

Prompt %.

Le Korn Shell (programme /bin/ksh) , plus récent, qui est une amélioration de BourneShell.

Prompt $ aussi.

On supposera dorénavant le Cshell (abr. csh).

Le premier programme donc qui est lancé par UNIX dès la connexion est un shell, généralement le csh. (C'est en fait le programme qui est donné, en fin de ligne No_compte_utilisateur dans le fichier /etc/passwd, exemple:

tounsi:BefaTUBy.Nt:273:20:TOUNSI Najib Pr. Ass:/shems/users/tounsi:/bin/csh

et qui peut être, soit dit en passant, autre chose qu'un shell)

Par la commande csh, on peut lancer plusieurs shells qui s'empilent. On les quitte individuellement, par ^D. Le dernier ^D (ou logout) quitte donc la session UNIX.

shell_1 est le shell de lancement, juste après le login. shell_2 est un deuxième shell lancé explicitement par la commande csh. De même pour shell_3. Les ^D quittent les shells successifs. Ordre LIFO (dernier entré, premier sorti). le dernier ^D quitte le shell de lancement, et donc la session UNIX. La commande logout ne marche que pour le premier shell. Voici d'ailleurs ce que donne la commande UNIX ps (Process Status) qui montre ici l'exécution de deux shells successifs.

PID TT STAT TIME COMMAND
10416 co IW 0:00 -csh (csh)       <-- shell de lancement
10526 p1 R 0:00 ps -x

après avoir fait csh

PID TT STAT TIME COMMAND
10416 co IW 0:00 -csh (csh)
10528 p1 S 0:00 -sh (csh)         <--2e shell (N^o.10528)
10537 p1 R 0:00 ps -x

et après ^D

PID TT STAT TIME COMMAND
10416 co IW 0:00 -csh (csh)       <--retour 1er shell
10545 p1 R 0:00 ps -x

A chaque lancement, csh exécute le fichier .cshrc, s'il existe dans le répertoire utilisateur appelé <<HomeDirerctory>>. (Les lettres finales rc signifient, en général sous UNIX, ReadCommand). Ce fichier contient les options de fonctionnement du shell: des définitions de variables shell (e.g. prompt) des alias de commandes etc... Pour le premier lancement (celui du login) csh exécute aussi le fichier .login s'il existe dans le répertoire utilisateur . Cette exécution vient après celle de .cshrc . Grosso-modo, l'algorithme shell est:

- Exécuter .cshrc si existe dans HomeDir
- Exécuter .login si existe dans HomeDir et je suis 1er shell
- Afficher prompt et lire commande
- TantQue (Commande != ^D et != logout)

- Exécuter Commande [3]
- Afficher prompt et lire commande

- FinTQ

3.2. Fichiers d'Environnement

Fichier .login

Le fichier .login (voir exemple plus bas) contient de façon standard

•  la reconnaissance et l'initialisation des caractéristiques du terminal de connexion (commande tset).
•  éventuellement, modification (commande stty) de certaines caractéristiques de la liaison dépendante du terminal, comme les caractères d'interruption (^C), d'effacement (^?) , etc...
•  l'initialisation (commande setenv) de certaines variables d'environnement nécessaires comme par exemple:

Voici d'ailleurs ce que donne la commande [4] shell env, qui affiche les variables d'environnement.

HOME=/shems/users/tounsi
SHELL=/bin/csh
TERM=sun
USER=tounsi
PATH=.:~:~/bin:/usr/ucb:/bin:/usr/bin:/etc:/usr/etc:
/usr/lib:/usr/local/bin:/usr/import/emacs)
PWD=/shems/users/tounsi/BOOKS/C

Un fichier standard .login, bien positionné (!?) par l'ingénieur système, est fourni pour chaque utilisateur (voir exemple plus bas). On rajoute en général dans ce fichier toute personnalisation qu'on souhaite apporter à sa session UNIX comme

alias rm "rm -i"

qui demande une confirmation avant toute suppression de fichier, ou

set ignoreeof

qui évite qu'une erreur de frappe ^D fasse quitter UNIX prématurément. Il faut taper logout textuellement dans ce cas. etc...

Comme il n'y a pas de login sans logout, il y a aussi la possibilité d'avoir un fichier .logout (non fourni en standard en principe), qui, comme on le devine facilement, s'exécute en fin de session juste après logout. Ce fichier peut servir à faire du nettoyage et effacer les fichiers de backup, a.out ou core (merci) etc ... et aussi à afficher des messages type agenda par exemple.

Exemple de fichiers .login et .cshrc

Voici un exemple de fichier .login relativement standard (issu de Digital ULTRIX 4.3)

stty dec new cr0
tset -I -Q
umask 022
setenv MAIL /usr/spool/mail/$USER
set mail=$MAIL
set path=($HOME/bin /usr/ucb /bin /usr/bin /usr/local /usr/new /usr/hosts .)
set prompt="`hostname`> "
setenv EXINIT 'set redraw wm=8'
biff n
date
alias rm rm -i

et de fichier .cshrc

if ($?prompt) then
set prompt = "csh> "
set notify
set history = 20
alias pd pushd
alias pop popd
alias vt52 "set term = vt52"
alias ti745 "set term = ti745 ; stty -tabs"
alias ti785 "set term = ti745 ; stty -tabs"
alias vt100 "set term = vt100"
endif

3.3. Variables Shell et Variables Environnement

Il existe donc des variables dont les valeurs sont significatives pour le bon déroulement d'une session (ou d'un programme à exécuter). Elles se repartissent en deux classes: variables shell et variables environnement.

• Les variables shell -- minuscules en général-- sont locales à un shell et ne sont pas transmises (exportées) aux programmes lancés depuis ce shell
• Les variables d'environnement --majuscules en général-- sont globales et sont vues par tous les programmes lancés.

La commande shell set permet d'afficher les variables du shell courant.  Par exemple:

et la commande env permet d'afficher les variables d'environnement comme on l'a déjà vu. Les variables dont la valeur est une liste entre parenthèses, sont des tableaux. qu'on peut manipuler par indexation (voir plus bas).

Parmi les variables shell, il y en a qui sont semblables (path, home, history... ) à leur homologue d'environnement. Elles sont héritées, et peuvent changer (par set) localement. On voit aussi une variable utilisateur v qui vaut toto. Les variables shell sont utiles au langage de commandes (comme dans un langage de programmation). On peut afficher le contenu d'une variable par echo.

% echo $v $term $HOME
toto sun /shems/users/tounsi
% echo $HISTORY
50
% echo $history
50
% set history=10
% echo $history
10
% echo $HISTORY
50

Apprécier le symbole $ qui permet de distinguer entre le nom d'une variable et son contenu ($var signifie contenu de var).

Les variables sont créées par set, pour les variables shell, et par setenv, pour les variables d'environnement. Pour les cas simples la syntaxe est:

set var = chaîne
setenv var chaîne (sans signe = )

C'est typiquement du remplacement de texte. Exemple:

% set a=toto
% set b="to to"
% setenv A titi
% echo $a $b $A
toto to to titi
% set
a toto
b to to
home /shems/users/tounsi
...
% env
HOME =/shems/users/tounsi
...
A=titi
% set prompt="csh>"
csh>set prompt="% "
%

On peut utiliser le contenu d'autres variables pour initialiser une variable

% set c="$a titi"
% echo $c
toto titi
% set d='$a titi'
% echo $d
$a titi
% set d=$atiti
atiti: Undefined variable.
% set d=${a}titi
% echo $d
tototiti

où on voit que les doubles quotes " " servent à inhiber l'interprétation de certains caractères (e.g. espace séparateur etc...) et les simples quotes ' ' à inhiber toute interprétation ($ ici). Les {} servant quant à elles, à délimiter le nom d'une variable dans un texte.

Le csh permet aussi de manipuler des variables numériques. Le symbole @ remplace set dans ce cas (mais le contenu est toujours $var).

% @ x = 2
% echo $x
2
% @ y = $x + 3
% echo $y
5
% @ x++
% echo $x
3

On verra plus loin ([[section]]4) que les variables sont très utiles dans des programmes en langage de commandes.

Mentionnons, avant de terminer cette partie, l'existence de variables shell booléennes comme: 

Ces variables sont positionnées par simple switch

% set var

qui met var alternativement à vrai ou faux.

Par ailleurs, on peut initialiser une variable par lecture sur le clavier. On écrit

set a = $<

Le symbole < est là pour indiquer le fichier entrée (voir plus loin les redirections).

Variables Tableaux

Les variables tableaux sont des variables qui contiennent plusieurs mots. On accède à chaque mot par un indice ($var[indice]) allant de 1 au nombre de mots présents. La variable path en est un exemple. On initialise une variable tableau en donnant la liste des mots entre parenthèses.

% set a = (a b c)
% echo $a
a b c
% echo $a[1] $a[3]
a c
% echo $a[4]
Subscript out of range
% echo $#a <--- nombre de mots
3
% set a[2] = B
% echo $a
a B c
% set a = (z $a d) <--- adjonction de mots
% echo $a
z a B c d
%

La notation $#var donne le nombre de mots dans la variable (taille du tableau), et $var est synonyme de la liste des mots actuels de la variable (contenu du tableau).