Actions sur le document

Les différents Shell Unix/Linux

Filed Under:

Unix
Linux

Aide mémoire

Ce sont des programmes ayant plusieurs fonctions:

dialogue avec les utilisateurs : lancement des commandes, arrêt et redémarrage, gestion d'un historique, d'éditions de commandes, de synonymes, de fonctions.
programmation de séquence de commandes. On dispose de variables, de structures de contrôle, et de toutes les commandes standard Unix (expr, test, sort, grep, awk, sed, tr, diff, comm, cmp, wc, head, tail, cut, paste, ...)

Il y a 2 familles:

les shells de type Bourne (sh, zsh, bash)
et les shells de type C-shell (csh, lcsh, tcsh). La syntaxe de ces derniers est inspirée de la syntaxe du C.

Lancement

En interactif, le comportement est différent selon que c'est un shell de login (= de démarrage) ou non.

sh lit .profile quand il est shell de login, rien sinon
csh lit le fichier .cshrc puis, s'il est de login, le fichier .login. csh sait s'il est interactif ou non à la présence de variables $term et $prompt:
```
	if ( $?prompt != 0 && $?term != 0 ) then
		echo je suis interactif...
	endif
```

Appel

Ce peut être un appel:

à la main:

	$ sh mon/fichier.csh
	$ tcsh -x mon/fichier.tcsh

implicite:
- le texte est mis dans un fichier
- que l'on rend exécutable: chmod +x ...
- dont la première ligne référence le bon interpréteur:
```
		#!/bin/sh
		#!/usr/local/bin/bash
```
- et on appelle alors le fichier par son nom. La variable d'environnement PATH permet de le retrouver, si l'on n'a pas indiqué le chemin complet:
```
		~/bin/mon.fichier
		mon.fichier # sous-entendu via le PATH
```

Syntaxe

Le format n'est pas du tout libre, mais par ligne.
Les commentaires sont introduits par un '#'.
Les identificateurs sont une lettre, suivi de lettres ou chiffres. Il y a des mots réservés.

Caractères spéciaux

Règle : chaque ligne subit des substitutions puis est interprété conformément à la syntaxe du shell.

Classe 1

On se base ici sur la liste des noms de fichiers (résultat de la commande ls):

? : ce caractère peut remplacer un seul caractère. Exemples:
```
	echo a.?ex
	for i in a.???
```
* : toute suite de caractères ne commençant pas par un . (lire : un point). Exemple:
```
	echo *
	echo .*
	echo .??*
	echo *.*
	echo *.???
```
[a-z] ou [st] : un caractère de la liste. Exemple:
```
	echo *.[st]*
	grep mot *.[ch]
```

Classe 2 : le $

On se base ici sur des variables internes au shell, distinctes des variables d'environnement.

$var est remplacé, en termes de texte par la valeur de la variable var. On regarde dans les variables internes au shell puis dans les variables d'environnement.
(csh) $var[index] accède le i-ème élément du tableau.
$0, $1, etc. sont les paramètres d'appel du shell. shift permet de jeter le premier argument.
$? (sh) ou $status (csh) est le code de retour de la dernière commande exécutée.
$# est le nombre d'arguments.
$$ est le numéro de process du shell.
$! est le numéro de process de la dernière commande lancé en background.
(csh) $#var donne le nombre d'éléments de la variable qui est un tableau
(sh) read var lit une variable sur l'entrée standard.
(csh) $< est lue sur l'entrée standard.

Classe 3: les protections

': ce qui est entre apostrophes n'est pas interprété. Exemple: echo '*'

" : ce qui est entre guillemets est interprété mais reste un seul mot. Exemple:

	showargs "*"	# un seul argument : la liste des fichiers
	showargs *	# n arguments si n fichiers

` : ce qui est entre apostrophes inverses est remplacé par le résultat de la commande:
```
	echo `date`
	echo `ls`
	a=`wc -l fichier`
```

Les redirections

Pour un shell, tout process a

une entrée standard (stdin de numéro 0),
une sortie standard (stdout de numéro 1),
une sortie d'erreur (stderr de numéro 2).

Par défaut, l'entrée standard est le clavier, la sortie standard et la sortie d'erreur sont l'écran.
Mais on peut rediriger:

process < file: lance un process avec en entrée standard le contenu du fichier.
process > file : lance le process avec en sortie standard le fichier. Ce fichier est détruit au lancement.
process >> file : lance le process avec en sortie standard le fichier mais on concatène au fichier s'il existe déjà.
p1 | p2 : la sortie de p1 devient l'entrée de p2.
p1 <<MotADefinir : met sur l'entrée standard ce qui vient dans le shell jusqu'à la ligne MotADefinir.
```
	cat <<FinDuMessage
	Ceci est le message.
	La suite.
	FinDuMessage
	date	# commande executee
```

En sh:

process 2>file redirige la sortie d'erreur
process 2>&1 concatène la sortie d'erreur à la sortie standard. Exemple:
```
	commande >file 2>&1	# bon
	commande 2>&1 >file	# mauvais
```

En csh:

process >& file concatène les 2 sorties dans le fichier.
(process > out) >& err pour les séparer.

Constantes, types de données

Il n'y a pas de constante, tout en shell est chaîne de caractères.

(csh) Les tableaux

Indicé à partir de 1.
Exemples:

	foreach i (*)
	ls = (*)
	set compte = ( un deux trois )

Les affectations en sh

var = valeur Si on a des calculs à faire, on se sert du programme expr(1).
Si on a des tests à faire, on se sert du programme test(1) appelé aussi '['.
Exemple:

	i = `expr $i + $j`
	i = `expr $i '*' 2`
	if [ $a = test ]
	if test $a = test
	if [ -f .profile ]

Les affectations en csh

@ var = expression

	@i = $i + $j
	@i = $i * 2
	if ($a == test) ...
	if (-f .cshrc) ...

Les instructions en sh

les affectations
les groupements ( cmd1; cmd2 )

les tests

	if condition
	then
		....
	elsif condition
		....
	else
		:
	fi

les boucles
```
	while condition
	do
		....
	done
```

les cas

	case expression in
	v1|v2) ....;;
	v3) ....;;
	*)	....;;
	esac

la sortie exit N

Les instructions en csh

les affectations
les groupements ( cmd1; cmd2 )

les tests

	if (condition) commande
	if (condition) then
		....
	else if (condition) then
		...
	else
		...
	endif

les boucles
```
	while (condition)
		....
	end
```

les cas

	switch (string)
	case v1:
		....
		breaksw
	default:
		....
	endsw

la sortie exit N

Ce qui fait la force et la richesse de Linux et d'autres systèmes d'exploitation issus d' UNIX est la richesse offerte par le mode console.

Il peut être nécessaire si vous voulez installer des programmes, ou si vous avez des difficultés à utiliser le mode graphique de passer par le shell.

Il est très souvent plus rapide d'entrer des commandes dans une fenêtre de terminal que d'utiliser l'interface graphique.

Pourtant, les personnes qui sont habituées à Windows ne sont pas familières avec cette philosophie.

Je vais donc vous présenter les concepts de base ainsi que les commandes essentielles pour être à l'aise avec le shell et apprécier tout le confort qu'il donne.

Le SHELL

Qu'est ce que le SHELL ?

Interface utilisateur/système

Exécution de commandes

Possibilité d'utilisation comme langage de programmation

Shell est un processus

Différents shells disponibles (bash,zsh, csh, tcsh...)

Bash par défaut sous Linux

Les différents SHELL

sh : Le shell Bourne, du nom de son créateur Steve Bourne pour AT&T. C'est le plus

ancien shell.

csh : Très proche du langage C. Créé par Bill Joy pour les systèmes BSD. Ajoute à sh

le rappel de commandes ainsi que les alias.

ksh : Créé par David Korn pour AT&T. Ajoute de nouvelles fonctionnalités au csh.

rsh : Shell sh restreint. Pas de commande cd, ni de redirections. La variables PATH

ne peut pas être modifiée.

bash : Bourne Again Shell. C'est un shell entièrement libre. Il a été crée par Brian

Fox et Chet Ramsey.

C'est le shell par défaut de Linux.

L'environnement utilisateur

/etc/profile:

Fichier d'initialisation pour tous les utilisateurs du système. Il est exécuté par les shells de login.

/etc/bashrc:

Fichier de démarrage commun à tous les utilisateurs.

~./bash_profile :

Fichier d'initialisation de l'utilisateur. Il est exécuté par le shell de login.

~./bashrc :

Fichier de démarrage personnel pour les shells interactifs.

~./bash_logout :

Fichier de sortie de shell de login, lors de la deconnexion de l'utilisateur.

~./inputrc :

Fichier d'initialisation personalisé de « readline ».

Les variables d'environnement

env :

liste des variables d'environnement système.

echo : (echo $variable) --> ex : echo $SHELL affiche le shell courant

affiche une variable d'environnement

export : (export variable) --> ex : export display=10.128.192.16:0.0

positionne la valeur d'une variable d'environnement

Les alias

Le fichier /etc/bashrc initialise un environnement commun à tous les utilisateurs du système.

Dans ce fichier, on pourra placer des alias valables pour tous les utilisateurs.

Exemples :

alias ll= « ls -l »

alias x= « startx »

alias qui= « who -Hu »

Si on saisit « ll » dans un terminal le résultat sera le même que si l'onavait saisit « ls -l »

Les scripts shell

Un script shell, est une suite de commandes mises dans un fichier caractérisé par :

#! : Placé sur la première ligne du script, le « sha-bang » désigne de manière explicite le shell qui doit exécuter le script.

Après le « sha-bang » on trouve le chemin vers le programme qui interprète le script

#!/bin/sh

#!/bin/bash

#!/usr/bin/perl

L'attribut exécutable (chmod u+x)

L'éxécution est réalisée par : ./script

Lancement d'un script :

Rendre le script exécutable :

$chmod 555 le_script

Donne le droit de lecture écriture à tout le monde

$chmod +rx le_script

Donne le droit de lecture et d'éxecution à tout le monde

$chmod u+rx le_script

Donne le droit de lecture et d'éxecution seulement au propriétaire

./le_script : exécute le script

Le répertoire courant n 'est pas inclus dans le PATH de l'utilisateur.

Il faut lancer le script de façon explicite dans le répertoire courant avec ./

Les commandes de bases

Fichiers et répertoires

Lister le contenu d'un répertoire

Ls [RadlF] [files]

Les options les plus utilisées sont:

-R: mode récursif

-a : inclut toutes les entrées même celles commençant par (.) (fichiers cachés).

-d : liste les propriétés d'un répertoire et non son contenu.

-l : liste avec tous les détails sur les fichiers.

-F : ajoute un (/) après chaque répertoire,(*) après chaque fichier exécutable, (@), après un lien symbolique.

Connaître son répertoire courant :

pwd

Se déplacer dans un répertoire :

cd [nom_répertoire]

Copie de fichiers

cp <fichier_source><fichier_destination>

cp <fichier_source><répertoire_destination>

cp -r <répertoire_source><répertoire_destination>

-i: mode interactif

-r: mode récursif (utilisé pour les répertoires)

-p: préserve le propriétaire, le groupe ID, les droits, et la date de dernière modification.

Supprimer des fichiers ou des répertoires

rm [-ifr] f1 f2 f3 ...fn

-i: mode interactif

-f: enlève tous les fichiers d'un répertoire sans demander de confirmation

-r: mode récursif sur les répertoires

Déplacer un fichier ou renommer un répertoire

mv [-fi] f1 f2 f3 ...fn

-i: mode intéractif

-f: déplace tous les fichiers sans demander de confirmation

mv <fichier_source><destination>

Gestion des répertoires :

Création

mkdir répertoire1...répertoireN (l'ordre hiérarchique doit être respecté)

Suppression d'un répertoire vide

rmdir repertoire1 repertoire2

Suppression d'un répertoire non vide

rm -r répertoire1 répertoire2

Permissions et droits d'accès

Permission sur les fichiers

3 catégories: r-read, w-write, x-exécution

3 classes d'utilisateurs: user, group, other

Permission sur les répertoires

r: possibilité de lire le contenu du répertoire (ls)

w: possibilité de détruire ce qui se trouve dans le répertoire (rm)

x: possibilité de traverser le répertoire (cd)

Il existe deux façons de noter les permissions sur un fichier:

Explicitement:

User group others

u g o

read write execute read write execute read write execute

r w x r w x r w x

Exemple: rwx_x__: tous les droits pour le propriétaire du fichier, les droits de lecture et d'exécution pour les membres du groupe et aucun droits pour les autres utilisateurs.

Numériquement:

User group others

u g o

read write execute read write execute read write execute

r w x r w x r w x

4 2 1 4 2 1 4 2 1

Exemple :

rwxrwxrwx = 4+2+1 4+2+1 4+2+1 = 777

rw_r__r__ = 4+2 4 4 = 644

chmod change les droits d'un fichier ou d'un répertoire.

Cette commande peut utiliser les deux représentations précédentes:

chmod u+x fichier : ajouter l'exécution pour le propriétaire

chmod 755 fichier : positionne les droits de fichier à 755.

chmod -R o+r répertoire : ajoute les droits de lecture pour les utilisateurs n'appartenant pas au groupe propriétaire.

Remarque : La lettre a (pour all) peut être utilisée avec chmod (chmod a+w fichier).

chown change le propriétaire d'un fichier ou d'un répertoire. Cette commande s'utilise de la façon suivante :

chown <new_user> fichier : change l'

Sections

Outils personnels