TABLE DES MATIERES
TABLE DES MATIERES...1
COMPRENDRE ET UTILISER UN SYSTEME D'EXPLOITATION...5
>> Qu'est-ce qu'un système d'exploitation ?...5
>> Modèle en couches...5
>> Modèle en couches concentriques...5
>> Introduction...6
> Caractéristiques :...6
> Fonctionnalités...6
>> Connexion et déconnexion à un système UNIX...6
> Procédure de connexion...6
> Mot de passe...7
> Procédure de déconnexion...7
> Connexion à distance...7
PREMIERES COMMANDES...8
>> Interpréteur de commandes...8
> Principaux interpréteurs...8
>> Syntaxe habituelle des commandes...8
>> Commandes usuelles...8
> Si on ne connaît pas la syntaxe de la commande...8
> Recherche des utilisateurs connectés...8
>> Fichiers et répertoires...8
> Commandes usuelles sur les fichiers...9
> Commandes usuelles sur les répertoires...9
>> Divers...9
>> Caractères génériques...9
>> Recherche de motifs dans un fichier...9
REDIRECTION DES ENTRÉES-SORTIES...10
>> Entrées-sorties de commandes...10
> La sortie erreur standard...10
> Entrée et sortie standards...10
>> Redirection de la sortie standard...10
> Redirection avec concaténation...10
> Affichage des sorties et redirection...10
> Mise en évidence de l'erreur standard...10
>> Redirection de l'entrée standard...11
>> Composition de commandes...11
> Tubes...11
> Aspect chronologique...12
> Généralisation...12
>> Enchaînement de commandes...12
> Parenthésage et enchaînement...12
>> Redirection de l'erreur standard...13
>> Redirections simultanées...13
>> Composition conditionnelle ET ALORS...13
>> Composition OU SINON...13
>> Lancement des commandes en arrière-plan (background)...13
>> Environnement d'un shell...13
> Affectation d'une valeur une variable...14
> Pour libérer une variable...14
INITIATION AU LANGAGE DE COMMANDE (BASH)...15
>> Scripts...15
> On peut faire plus fin...15
> Messages de sortie...15
> Paramètres d'un script...15
> Parenthésage des commandes...15
> Notation des paramètres...16
>> Expressions conditionnelles...16
> Expressions conditionnelles sur fichiers...16
> Expressions conditionnelles sur entiers (tests numériques sur des nb entiers)...16
> Expressions conditionnelles sur chaînes (tests élémentaires sur chaînes)...17
> Expressions conditionnelles sur booléens...17
> Pièges des tests...17
> Exemple...17
> Combinaisons de conditions...17
> Deux manières de procéder...17
>> Structure de contrôle conditionnelle...18
> Syntaxe...18
>> Structure de contrôle par aiguillage...18
> Syntaxe...18
>> Structure de contrôle itérative...19
> Itérative explicitement bornée...19
> Itératives non explicitement bornées...19
> Itérative de type tant que...19
> Itérative de type jusqu’à ce que...19
> Ejection d’itérative...19
APPROFONDISSEMENT DU LANGAGE DE COMMANDE...20
>> Métacaractères...20
>> Expansion des noms de fichiers...20
>> Règles du mécanisme d’expansion...20
> Exceptions...20
>> Délimiteurs de chaînes...20
> Délimiteur quote ’...20
> Délimiteur doublequote "...21
> Délimiteur antiquote `...21
>> Calculs...21
> Syntaxe...21
>> Arithmétique entière...22
>> Incrément, décrément...22
> Mécanisme d’incrémentation...22
>> Décalage d’arguments...22
>> Fonctions...22
>> Variables de position...23
>> Substitutions conditionnelles...23
>> Expressions conditionnelles sur chaînes...23
>> Classes de caractères...23
COMPLEMENTS SUR L’ENVIRONNEMENT...25
>> Variables d’environnement...25
>> Variables locales et d’environnement...25
>> Exportation...25
>> Manipulation des variables...25
>> Initialisation de l’environnement...25
>> Lors de l’exécution d’un script...26
>> Définition de synonymes...26
> Fichier d’alias...26
>> Le répertoire utilisateur...26
>> Chemin de recherche des commandes...26
> Recherche de commande...26
> Modifier le chemin de recherche...27
LES EXPRESSIONS REGULIERES...28
>> Expressions régulières (ou rationnelles)...28
>> Les caractères spéciaux...28
>> Expressions régulières atomiques...28
>> Expressions régulières générales...29
LES SYSTEMES DE FICHIERS...31
PRINCIPE D’ORGANISATION...31
>> Notion de fichier...31
>> i-nœuds...31
>> Identification d’un fichier...31
>> Le type d’un fichier...31
>> Catégories de fichiers...31
>> Répertoires...31
>> Référençage...32
>> Organisation des arborescences...32
>> Montage...32
> Montage distant...32
LES REFERENCES...32
>>Fichiers accessibles et chemins d’accès...32
>> Références absolues...33
>> Répertoires de travail...33
>> Références relatives...33
>> Les liens .. et ....33
>> Répertoires (presques) vides...33
>> Répertoire privé...33
LES DIFFERENTS TYPES DE FICHIERS...33
>> Les fichiers ordinaires ou réguliers...33
>> Les répertoires usuels...33
>> Les fichiers spéciaux...34
>> Modes de fichiers spéciaux...34
>> Autres types de fichiers...34
>> Structure des nœuds d’index...34
LES DROITS D’ACCES AUX FICHIERS...34
>> Les groupes d’utilisateurs...34
>> Catégories d’utilisateurs d’un fichier...34
>> Les types d’opérations...35
>> Indicateurs de mode d’un fichier...35
>> Mode x pour des répertoires...35
>> Modes r et w pour des répertoires...35
>> Répertoires et modes...35
>> Le cas des fichiers...35
> Remarques...35
>> Le super utilisateur...36
>> Propriétaire d’un fichier...36
>> La commande su...36
>> Changer les attributs d’un i-nœud...36
> Remarque...36
>> chmod en détail...36
>> Codage octal des modes...36
>> Application : échanger des données...37
>> Bits spéciaux...37
> Le set-uid bit...37
> Le set-gid bit...37
> Le sticky bit...37
>> Codage complet à 4 bits...38
>> Expressions conditionnelles sur fichiers...38
APPROFONDISSEMENT DES COMMANDES LIEES AUX SYSTEMES DE FICHIERS...38
>> La commande ls –options Argts...38
>> La commande cp...38
>> La commande mv...39
>> La commande rm...39
>> Nouveau lien physique...39
>> Liens symboliques (mous)...39
>> Effet de rm sur les liens...40
>> La commande tar...40
>> La commande df...40
>> La commande du...40
RECHERCHE DE FICHIERS...41
>> La commande find...41
LES PROCESSUS...42
GENERALITES...42
>> Concept de processus...42
>> Constitution d’un processus...42
>> Bloc de contrôle du processus...42
>> Ordonnanceur...42
>> Caractéristiques d’un processus...42
>> La commande ps...42
>> La terminaison des processus...43
>> Modification de priorité...43
CLASSES DE PROCESSUS...43
>> Partage de temps...43
>> Concept des classes d’ordonnancement...44
>> Démons et processus utilisateurs...44
>> Démons...44
> INIT...44
> LPSCHED...44
> CRON...44
> INETD...44
>> Les processus utilisateurs après connexion...45
>> Autre genèse de processus utilisateurs...45
>> Commande at...45
>> Les signaux...45
>> Exécution : programmes réentrants...45
>> Mode utilisateur et mode noyau...45
>> Génétique des processus et fonction fork...46
>> Code après terminaison d’un processus...46
>> Terminaison interactive des processus...46
>> Contrôle des tâches...46
>> Gestion du terminal...46
DEMARRAGE DES SYSTEMES D’EXPLOITATION DE TYPE...47
>> Généralités...47
>> Etude fine de chaque étape du démarrage...47
1. Réveil du système...47
2. Configuration du système...47
3. Lancement des services...48
4. Donner la main à un utilisateur...48
! " # $
COMPRENDRE ET UTILISER UN SYSTEME D'EXPLOITATION
>> Qu'est-ce qu'un système d'exploitation ?
Fonctions : saisie et restitution de l'information (gestion des E/S) stockage de l'information (gestion de la mémoire) traitement de l'information (exécution de programmes) préparation et mise au point des programmes
>> Modèle en couches
Répartition des tâches entre matériel et logiciel On peut hiérarchiser les tâches ainsi
Application Machine virtuelle 2 Logiciel de base Machine virtuelle 1 Machine physique Machine réelle Logiciel de base
Se compose de
Outils et services : compilateurs, chargeurs, éditeurs...
Système d'exploitation
Outils et services sont interchangeables et peuvent être partiellement ou totalement absents.
Le système d'exploitation est indispensable et c'est lui qui masque le matériel.
>> Modèle en couches concentriques
On peut modéliser ainsi un système d'exploitation : au niveau le plus central : l'exécutif, entouré de
• l'interface utilisateur (graphique ou langage de commande)
• système de gestion de fichiers (mémoire de masse)
• gestion de système (ressources utilisateurs)
• communication (réseaux)
l'exécutif peut lui-même être décomposé en un noyau (kernel) qui s'occupe de
• gestion du processeur
• gestion des E/S
• gestion du temps
• gestion de mémoire Exemples :
Ordinateur personnel : Systèmes d'exploitation courants : MS-DOS, Win XX, MacOS gestion des fichiers : création, modification, suppression
E/S : écrans, imprimantes exécution des programmes
interface utilisateur : langage de commande ou graphique
Système à temps partagé : Les fonctions sont les mêmes qu'un PC et de plus gestion des utilisateurs : espace de travail, droits d'accès
partage des ressources communes : imprimantes, disques
gestion des communications : informations partagées, communication entre utilisateurs
SYSTEME UNIX
>> Introduction
> Caractéristiques :
multi-tâches (multi-processeurs) et multi-utilisateurs
très grande facilité d'intégration en réseaux, interface texte ou graphique cf. livre RIFFLET (J. M.), La programmation sous Unix, EdiScience
> Fonctionnalités 4 principales :
gestion des ressources de l'ordinateur
Unix est un système d'exploitation multi-tâches et multi-utilisateurs
• le temps d'utilisation du processeur de l'ordinateur est réparti entre différentes tâches, ce qui se traduit par l'exécution simultanée de programmes
• Unix traite les commandes de plusieurs utilisateurs en même temps Il répartit les ressources entre les différentes tâches et utilisateurs de façon transparente pour ces derniers.
gestion des données
Celle-ci consiste en l'organisation, la maintenance et l'accès aux unités de stockage (mémoire vive, disques durs, bandes magnétiques...)
communication entre utilisateurs
C'est par exemple le courrier électronique ou les transferts de fichiers dont l'utilisation sera étudiée ultérieurement.
environnement de programmation
Ce sont les compilateurs (C et quelquefois FORTRAN), éditeurs de texte, outils d'aide à la programmation (débogueurs...)
>> Connexion et déconnexion à un système UNIX
On suppose que l'utilisateur a déjà été enregistré sur le système et que donc son identité est présente dans les fichiers particuliers gérés par l'administrateur du système.
> Procédure de connexion
Celle-ci peut être scindée en 2 phases : connexion logique
Doit avoir lieu entre le terminal (écran + clavier) et l'ordinateur sur lequel on veut travailler.
Le terminal peut aussi être un autre ordinateur (station Unix, PC, Mac...).
Cette connexion dépend de la liaison matérielle entre le terminal et l'ordinateur.
Dans le cas le plus simple de la liaison directe, il suffit d'allumer le terminal.
initialisation de la session de travail
C'est durant cette étape que l'utilisateur va devoir s'identifier auprès du système.
Cette identification a lieu de la façon suivante :
• affichage « login ? » après lequel il faut rentrer son nom d'utilisateur
• affichage « password ? » après lequel il faut rentrer son mot de passe (non affiché pendant la frappe)
• Puis, souvent, message demandant de spécifier le type de terminal utilisé (ex : vt100) et ceci de façon à ce que les éditeurs fonctionnent correctement. Sinon, un type de terminal est pris par défaut.
Après la connexion, différents messages de l'administration du système sont affichés (mot du jour, présence de courrier...).
L'utilisateur est prêt à travaille quand il reçoit l'invite du système consistant en un marqueur en début de ligne. Il est variable selon les machines.
Ex : $ ou NomUtilisateur@NomMachine >
> Mot de passe Changement
$ passwd ou yppasswd (yellow pages) current : (ancien) new : (nouveau) new bis : (nouveau) Qualités d'un « bon » mot de passe
Pas de données connues Au moins 7 caractères
Majuscules / minuscules / chiffres / ponctuation Introuvable dans les dictionnaires
Pas de répétition de caractères
Mot de passe tapé ======= crypt =======> comparaison avec l'enregistré (crypté)
> Procédure de déconnexion
Dépend du type de session ouverte :
si environnement graphique (XWindow) => menu logout sinon, commande logout ou exit
> Connexion à distance
telnet, rlogin : en voie de disparition (mots de passe circulent en clair sur le réseau !) ssh : crypté => meilleure sécurité. Actuellement : version 2 nécessaire.
Ex : ssh sun.ime.unicamp.br login ? johndoe
password ? ********
PREMIERES COMMANDES
>> Interpréteur de commandes
Fenêtre dans laquelle l’utilisateur tape des commandes (lorsque l’invite de commande apparaît).
Toute commande entrée sera interprétée par le shell (=interpréteur de commandes).
Le terme shell (coquille) exprime l’idée d’interface entre utilisateurs et système UNIX et a été donné par opposition au noyau du système.
> Principaux interpréteurs C-shell (csh)
Bourne-shell (sh) et sa variante bash (Bourne again – shell) Korn-shell (ksh)
Le choix du shell est fait à l’enregistrement de l’utilisateur dans le système. Il peut être modifié par la commande chsh.
>> Syntaxe habituelle des commandes
NomCommande [-Options] [Arguments]
Caractère séparateur entre les différents éléments : espace
Les options commencent habituellement par – suivi d’une ou plusieurs lettres-clés sans espace.
Les arguments spécifient les objets sur lesquels la commande va s’appliquer.
Les crochets autour des arguments et des options signifient que ceux-ci sont optionnels.
Ex : ls liste fichiers du répertoire courant ls -l donne tous les attributs des fichiers
ls -la liste aussi les fichiers commençant par . ls -l Rep1 liste fichiers du répertoire Rep1
ls -latr Rep1 liste fichiers de Rep1 par ordre chronologique ls -R Rep1 liste récursivement les sous répertoires
cat Fic1 permet de visualiser le contenu de Fic1
cat Fic1 Fic2 permet de visualiser le contenu de Fic1 et Fic2 /!\ Les shells UNIX respectent la casse !!!
>> Commandes usuelles
man Commande : aide en ligne sur Commande
> Si on ne connaît pas la syntaxe de la commande man –k motclé (recherche par mot-clé) Ex : man –k list
man –k directories
> Recherche des utilisateurs connectés
who affiche la liste des utilisateurs connectés sur la machine où l’on travaille.
>> Fichiers et répertoires
Fichier : objet typé dont le type définit l’ensemble des opérations qui peuvent lui être appliquées.
Fichiers réguliers : fichiers disques dont le contenu est non structuré.
Répertoires : servent à repérer des fichiers.
> Commandes usuelles sur les fichiers more Fic
RC affiche la ligne suivante (RC = Retour Chariot = ) SPACE affiche la page suivante
/Chaîne recherche de Chaîne h permet d’obtenir de l’aide
q ou Q RC permet d’abandonner l’affichage pg Fic
-RC affiche la page précédente
toutes les options de more sont valables lp Fic (line printer)
cp Fic1 Fic2 ou cp Fic1 Fic2 … Rep (copy) mv Fic1 Fic2 ou mv Fic1 Fic2 … Rep (move) rm Fic1 Fic2 (remove)
rm : /!\ pas de récupération possible
avec une configuration inconnue, toujours utiliser rm protégé par l’option i rm –i Fic
> Commandes usuelles sur les répertoires pwd (print working directory)
cd Rep (change directory)
cd .. remonte au dossier parent cd revient au répertoire par défaut mkdir (make directory)
rmdir (remove directory) /!\ les répertoires doivent être vides rm –r Rep /!\ destructions récursive
>> Divers
clear efface l’écran
who date affiche la date / permet de la modifier mail NomUtilisateur ou mail
Ex : $ mail johndoe
Le texte du message
éventuellement sur plusieurs lignes . (terminé par un point isolé sur une ligne) mail NomUtilisateur < Fic.ext
Ex : mail johndoe < Fic.txt
>> Caractères génériques
Certaines commandes acceptent plusieurs noms de fichiers en arguments.
? est équivalent à n’importe quel caractère autre qu’un point en début de ligne
* est équivalent à n’importe quelle chaîne de caractères ne commençant pas par un point, y compris la chaîne vide
mécanisme d’expansion
>> Recherche de motifs dans un fichier
fic : a $ grep ’aba’ fic $ grep –v ’aba’ fic
ab aba a
aba abab ab
abab
REDIRECTION DES ENTRÉES-SORTIES
>> Entrées-sorties de commandes
Un des grands intérêts d'Unix est de pouvoir composer des commandes, sans avoir à les modifier.
Il est nécessaire pour cela d'avoir des mécanismes permettant de rediriger le flux de sortie d'une première commande sur l'entrée d'une deuxième commande.
> La sortie erreur standard
Lorsqu'une commande Unix détecte une anomalie, elle envoie généralement un message sur la sortie d'erreur standard. En mode interactif, ce message est envoyé à l'écran.
> Entrée et sortie standards
En général, les commandes lisent l'entrée standard (clavier) et/ou écrivent sur la sortie standard (écran)
Il est possible de rediriger ces entrée et sortie standards vers des fichiers.
>> Redirection de la sortie standard
Pour que le résultat d'une commande soit rangé dans un fichier FicSortie au lieu d'apparaître à l'écran, il faut utiliser la syntaxe
NomCommande [-options] [argts] > FicSortie Ex : cat fic1 fic2 > ficConcat12
date > Fic (enregistre la date/heure)
who > Fic (enregistre les utilisateurs connectés)
> Redirection avec concaténation
Si le fichier FicSortie existe déjà, son contenu est écrasé avec la redirection >.
Si on veut que son contenu soit préservé et y ajouter des résultats d'une commande, il faut utiliser la redirection avec concaténation >>.
NomCommande [-options] [argts] >> FicSortie
> Affichage des sorties et redirection
Ex : supposons que le répertoire Rep contienne un fichier NomFic1 et pas NomFic2.
Dans ce cas,
$ ls NomFic1
NomFic2 not found NomFic1
La première ligne d'affichage correspond à l'affichage de l'erreur standard et la deuxième à la sortie standard de ls.
> Mise en évidence de l'erreur standard Première ligne = erreur standard
COMMANDE
Entrée standard
Sortie standard Erreur standard
Deuxième ligne = sortie standard Preuve
Redirigeons la sortie standard vers un fichier Resultat.
$ ls NomFic1 NomFic2 > Resultat NomFic2 not found
=> seule la première ligne correspondant à l'erreur standard subsiste.
On peut vérifier ce que contient Resultat
$ cat Resultat NomFic1
>> Redirection de l'entrée standard
Au lieu de fournir des données en les tapant au clavier, ces données peuvent être lues dans un fichier FicEntrée avec la syntaxe
NomCommande [-options] [argts] < FicEntrée Ex : Soit un fichier Fic composé de
aa bb cc ddd eee
Pour mettre tout en majuscules, on peut effectuer
$ tr '[a-z]' '[A-Z]' < Fic ou
$ tr '[[:lower:]]' '[[:upper:]]' < Fic
>> Composition de commandes
Composer deux commandes, c'est faire opérer une commande sur le résultat fourni par une autre.
On pourrait
rediriger la sortie de la première commande vers un fichier FicInter
puis rediriger l'entrée de la deuxième commande afin qu'elle lise ce fichier FicInter
puis supprimer FicInter
> Tubes
En Unix, on peut utiliser le mécanisme de tube (pipe) qui permet de prendre la sortie standard d'une première commande
et la rediriger sur l'entrée standard d'une deuxième commande
NomCommande1 [-options] [argts] | NomCommande2 [-options] [argts]
COMMANDE
FicEntrée
Sortie standard Erreur standard
COMMANDE 1 Entrée
standard Erreur
standard
COMMANDE
2 Erreur
standard Sortie standard
Ex :
$ ls /etc | more
$ ls -a | head
$ ls -la *.* | grep john
$ tar -cvf - . | gzip > /tmp/Rep.tar.gz
(conversion de l'arborescence du répertoire courant en un fichier, puis compression)
$ gunzip /tmp/Rep.tar.gz | tar -xvf (opération inverse)
> Aspect chronologique
Les commandes liées par un tube sont concurrentes : elles s'exécutent simultanément
elles sont synchronisées par le système
Ceci veut dire que la deuxième commande est lancée en même temps que la première, la deuxième est alors bloquée jusqu'à ce que la première ait fini le remplissage du tube.
Éventuellement, la première commande peut-être temporairement bloquée si le tube est plein.
> Généralisation
On peut écrire une cascade de commandes
$ Com1 | Com2 | ... | ComN
Cela ne présente de l'intérêt que si les N-1 premières commandes écrivent sur leur sortie et les N-1 dernières lisent sur leur entrée.
Une commande qui lit sur l'entrée standard et écrit sur la sortie standard est appelée un filtre.
Ex : cat, wc, sort, grep sont des filtres echo, ls n'en sont pas
>> Enchaînement de commandes
On peut enchaîner des commandes qui vont s'exécuter de manière indépendante.
On utilise la notation ; qui est un séparateur de commandes.
Ex : $ date ; echo "Bonjour, je suis : " ; whoami Wed Oct 1 14:26:02 MET 2004
Bonjour je suis :
johndoe ttyp1 Oct 1 14:26
> Parenthésage et enchaînement NE PAS CONFONDRE
(echo debut ; date ; echo fin) > FicP
qui n'affiche rien et qui va construire le fichier FicP de contenu debut
Wed Oct 1 14:26:02 MET 2004 fin
ET echo debut ; date ; echo fin > FicSP qui va afficher
debut
Wed Oct 1 14:26:02 MET 2004 et construire le fichier FicSP de contenu fin
>> Redirection de l'erreur standard
On peut souhaiter rediriger la sortie d'erreur standard vers un fichier plutôt que vers l'écran (par exemple pour garder la trace d'une erreur du traitement d'un nombre important de commandes).
La syntaxe est NomCommande 2> FicErreur (1 => sortie standard (facultatif), 2 => erreur standard).
Si on veut éliminer les messages d'erreurs, on peut les rediriger vers le fichier « trou noir » /dev/null.
Ex : $ ls -la NomFic1 NomFic2 2> /dev/null NomFic1
(NomFic2 absent => erreur supprimée)
>> Redirections simultanées
On peut décider de rediriger erreur et sortie standard, chacune vers un fichier particulier NomCommande > FicSortie 2> FicErreur
ou
NomCommande 1> FicSortie 2> FicErreur
A l'issue de l'exécution d'une commande Unix, cette commande produit un code : 0 si la commande s'est effectuée normalement
différent de 0 si la commande a constaté une erreur Pour récupérer ce code d'erreur : echo $?
>> Composition conditionnelle ET ALORS Com1 && Com2
Com2 ne s'exécute que si Com1 a réussi (code 0).
>> Composition OU SINON Com1 || Com2
Com2 ne sera exécutée que si Com1 a renvoyé un code non nul (« échec »).
>> Lancement des commandes en arrière-plan (background) Com1 &
Ex : xclock &
Chaque processus a un numéro PID (processus identification). Ce numéro s'obtient par la commande ps.
On peut contrôler un processus avec ce PID.
Ex : pour l'arrêter, en général : kill -9 PID ou kill -KILL PID
>> Environnement d'un shell
PATH EDITOR LOGNAME MAIL SHELL HOME TERM PS1 PS2
Ensemble de variables dont les valeurs sont ensuite utilisées par le shell.
Liste de toutes les variables d'environnement donnée par la commande env.
PS1 = invite PATH : /bin
$HOME/bin etc...
Nom de la variable : HOME
Valeur de la variable : $HOME : /home/etud/iq1/NomLogin EDITOR : vi => éditeur préféré
LOGNAME : $LOGNAME vaut NomLogin TERM : vt100, xterm...
Ex : echo $SHELL $ echo $PS1
/bin/bash $
$ echo $TERM xterm
D'une manière générale, on accède à la valeur d'une variable de nom NomVar par echo $NomVar.
> Affectation d'une valeur une variable
NomVar=LaValeur (!!! sans espace !!!)
> Pour libérer une variable unset NomVar
INITIATION AU LANGAGE DE COMMANDE (BASH)
>> Scripts
On va écrire des scripts : fichiers texte (lisibles) qui contiennent des commandes qu'on devrait taper à la main.
Dans un deuxième temps, on donnera le fichier script à lire et à exécuter (= interpréter) par /bin/bash.
Ces commandes listées dans le script sont interprétées dans l'ordre.
Ex de fichier script :
#!/bin/bash
# ce script sert d'exemple à ce cours echo "Mon nom de login est : "
echo $LOGNAME
Ensuite, on donne à ce fichier script monScript le mode exécutable
chmod u+x monScript (u+x : donne pour utilisateur la qualité exécutable) Pour l'exécuter, on tape simplement
monScript
Le script s'exécute séquentiellement jusqu'à la dernière ligne du fichier de script, ou bien jusqu'à ce qu'il rencontre une commande exit.
> On peut faire plus fin
exit 0 si je veux sortir avec un code de retour 0
exit N (où N est un entier différent de 0) si on veut sortir avec le code d'erreur N.
> Messages de sortie avec echo
echo -e si on veut des traitements spéciaux de lignes
$ echo -e "\n Sur 3 lignes \n"
(_
Sur 3 lignes _
> Paramètres d'un script
Ex : compRep : script qui compare les fichiers de 2 répertoires Rep1 Rep2 Rep1 peut être /bin
Rep2 peut être /home/archives/bin
La comparaison est une méthode indépendante des données.
On va appeler compRep sur 2 arguments
compRep /bin /home/archives/bin /bin va s'identifier à $1
/home/archives/bin va s'identifier à $2 et dans le script, on aura par exemple
_..._
_..._
ls $1/* <= cela réalisera ls /bin/*
_..._
> Parenthésage des commandes
On peut regrouper une séquence de commandes (séparées par des ;)
entre () : la séquence est exécutée dans un sous-shell du shell courant entre {} : la séquence est exécutée dans le shell courant
{ doit être suivie d'un espace
} doit être précédée d'un ; ou se trouver en début de ligne
> Notation des paramètres
Sont désignées par $1, $2, ..., $9 les valeurs des 9 premiers arguments de la commande correspondant au script.
La valeur $0 correspond au nom de script.
La valeur $* correspond à la liste des arguments.
La valeur $# correspond au nombre d'arguments.
La valeur $? correspond au code de retour de la dernière commande.
La valeur $$ correspond au numéro du processus courant.
>> Expressions conditionnelles
Éléments de base des structures alternatives.
La commande d'évaluation d'une expression conditionnelle peut prendre l'une des deux formes suivantes :
test ExprTest
[ Exprtest ] (!!! les espaces après [ et avant ] sont indispensables !!!) Lorsque cette commande est interprétée, elle donnes un code de retour nul ou non nul.
On dit que cette commande prend la valeur VRAI si le code de retour est nul.
Ex : test -a Fic ou [ -a Fic ]
(-a : code de l'opération de test « existence d'un fichier ») est VRAI si et seulement si le fichier Fic existe.
On pourra ensuite créer une alternative avec une syntaxe du type if [ -& Fic ] ; then Com1 ; else Com2 ; fi
> Expressions conditionnelles sur fichiers
ExprTest Vraie si
-f Fic Fic désigne un fichier régulier -d Rep Rep désigne un répertoire
-s Fic Fic existe et est de taille non nulle Fic1 -nt Fic2 Fic1 est plus récent que Fic2 Fic1 -ot Fic2 Fic1 est plus ancien que Fic2
> Expressions conditionnelles sur entiers (tests numériques sur des nombres entiers)
ExprTest Vraie si
Nbre1 -eq Nbre2 Égalité numérique Nbre1 -ne Nbre2 Inégalité numérique Nbre1 -gt Nbre2 Plus grand numérique
Nbre1 -ge Nbre2 Plus grand ou égal numérique Nbre1 -lt Nbre2 Plus petit numérique
Nbre1 -le Nbre2 Plus petit ou égal numérique
> Expressions conditionnelles sur chaînes (tests élémentaires sur chaînes)
ExprTest Vraie si
-n Chaîne Chaîne de longueur non nulle -z Chaîne Chaîne de longueur nulle Chaîne = Motif Chaîne satisfait le Motif shell Chaîne != Motif Inégalité
> Expressions conditionnelles sur booléens
ExprTest Vraie si
! Bool Bool faux (négation) Bool -a Bool2 Conjonction logique (et) Bool -o Bool2 Disjonction logique (ou)
ATTENTION : ne pas confondre avec les connecteurs d'expressions conditionnelles &&
et ||.
> Pièges des tests
Bien distinguer les valeurs numériques des valeurs chaînes, et leur appliquer la bonne syntaxe.
Ex : test "01" -eq "1" retourne VRAI (echo $? donne 0) test "01" = "1" retourne FAUX (echo $? donne 1)
> Exemple
$ Var1="dijon" ; Var2=""
$ [ $Var1 != $Var2 ]
/bin/bash : test : argument expected
La commande test évalue d'abord chacun de ses arguments. Or ici, la valeur $Var2 est la chaîne vide, qui n'est pas acceptée comme argument valide par test.
Ceci peut se produire à chaque fois qu'un des arguments de test a comme valeur la chaîne vide, ou n'a pas de valeur (par exemple si une variable Var n'est pas initialisée).
Si on ne peut pas exclure l'éventualité d'une chaîne vide, le remède consiste à encapsuler par des délimiteurs doublequote (") les membres d'expressions qui peuvent donner une valeur de chaîne vide.
On peut modifier l'exemple ainsi :
$ [ $Var1 != "$Var2" ] ; echo $?
0
> Combinaisons de conditions
> Deux manières de procéder
au niveau des expressions conditionnelles elles-mêmes avec des notations -a -o !
au niveau des évaluations d'expressions, avec la syntaxe commune aux commandes générales (parenthèses, &&, ||)
Combinaison Interprétation
! Comtest Négation
Comtest1 && Comtest2 Conjonction logique (et) ComTest1 || ComTest2 Disjonction logique (ou)
Ex : $ test ! "01" –eq "1" ; echo $?
1
$ [ ! "01" –eq "1" ] ; echo $?
1
$ ! test "01" –eq "1" ; echo $?
1
$ ! [ "01" –eq "1" ] ; echo $?
1
$ [ 0 –eq 0 –o 9 –eq 1 ] ; echo $?
0
$ ! [ 0 –eq 0 –o 0 –eq 1 ] ; echo $?
1
>> Structure de contrôle conditionnelle
> Syntaxe
if CommPred ; then Instr1 ; else Instr2 ; fi On peut remplacer les ; par des sauts de ligne :
if CommPred
then Instr1 else Instr2 fi
=> CommPred est évaluée. Si code de retour nul >>> Instr1 est évaluée, sinon Instr2 l’est (mais c’est facultatif).
Exemple de syntaxe complète : if CommPred1
then Instr1 elif CommPred2
then Instr2 elif CommPred3
then Instr3 else InstrF
fi
CommPred1 est évaluée. Si code de retour nul => Instr1 est évaluée, sinon on est ramené à une forme identique, mais de longueur réduite.
>> Structure de contrôle par aiguillage
> Syntaxe
case Chaîne in
Motif1) Instr1 ;;
Motif2) Instr2 ;;
Motif3) Instr3 ;;
…
MotifN) InstrN ;;
esac
Les motifs sont très souvent des entiers, et généralement, le dernier motif MotifN est le motif par défaut *.
Exemple : Ceci est utile pour les menus
#!/bin/bash
echo "quel éditeur souhaitez-vous ?"
echo –e "1 -> emacs, 2 -> xedit, 3 -> vi, \c"
echo "autre -> ed"
read Choix case $Choix in
1) EDITOR=emacs ;;
2) EDITOR=xedit ;;
3) EDITOR=vi ;;
*) EDITOR=ed ;;
esac
echo $EDITOR "est votre éditeur"
>> Structure de contrôle itérative
> Itérative explicitement bornée
for Var in Mot1 Mot2 … MotN do Instr
done Remarque :
Une forme plus courte omet in… quand la liste des mots coïncide avec $* (liste des arguments de la commande associée au script).
Ex :
for NomFich in fic1 fic2 fic3 do cat $NomFich
done Ex :
Supposons que Rep ne contienne que des fichiers texte avec extension .txt. Pour voir les 10 premières lignes de chaque fichier de Rep :
for NomFic in Rep/*.txt do head $NomFic done
Remarque : ceci ne fonctionne que si le mécanisme d’expansion (remplacement de *) n’est pas désactivé.
> Itératives non explicitement bornées
> Itérative de type tant que while CommPred
do Instr done
> Itérative de type jusqu’à ce que until CommPred
do Instr done
> Ejection d’itérative
- break : éjecte de la structure itérative dans laquelle elle figure
- break Nbre : éjecte de Nbre structures itératives successivement imbriquées Cette commande ne sera employée qu’en cas d’absolue nécessité.
APPROFONDISSEMENT DU LANGAGE DE COMMANDE
>> Métacaractères
Les métacaractères (ou caractères spéciaux) interviennent dfans les mécanismes suivants : - commentaires dans un fichier interprété par le shell : #
- protection (ou déspécification) : \ : placé devant un caractère spécial, il lui enlève son interprétation particulière
- séparation de mots : _ (blancs) - redirections : > >> <
- lancement de commandes : ; (séquentiel), | (conccurent), & (arrière-plan) - substitution à une variable de sa valeur : * ? [ [! ]
- délimitation de chaînes : ’ (quote), " (doublequote), ` (antiquote) - historique
- complétion de noms de fichiers.
>> Expansion des noms de fichiers
Ce mécanisme permet d’engendre une liste de noms de fichiers à l’aide d’une simple notation.
Il peut être désactive (bash –f).
Ex : *.c est une notation génératrice de la liste des fichiers du type chaîne.c où chaîne peut être vide, mais ne comporte pas de \ et ne peut commencer par ..
Ainsi, ls *.c se déroule de la manière suivante :
- la liste de tous les fichiers du type *.c est constituée - la commande ls est appliquée à cette liste de fichiers.
>> Règles du mécanisme d’expansion Métacaractère Signification
? un caractère quelconque
* une chaîne quelconque (vide permis) [ début de définition d’une ensemble
[! début de complémentaire de définition d’un ensemble ] fin de définition d’un ensemble
- marque d’intervalle dans un ensemble
> Exceptions
Les . en début de mot ou immédiatement derrière un \.
Les \.
>> Délimiteurs de chaînes Ils sont de 3 types :
- caractère ’ (quote)
- caractère " (doublequote) - caractère ` (antiquote)
> Délimiteur quote ’
Tous les caractères entre deux quotes sont protégés (s’ils ont un caractère spécial, ils le perdent).
Aucune substitution d’une valeur à un nom de variable ne s’effectuera lors de l’évaluation de la chaîne entre quotes.
Ex : $ Var="john"
$ echo $Var john
$ echo ’$Var’
$Var
> Délimiteur doublequote "
A l’intérieur d’une chaîne avec doublequotes les caractères $ \ ’ ` restent spéciaux.
On peut utiliser le caractère " dans une telle chaîne, mais il faut le protéger en l’écrivant
\". En particulier, la substitution des variables (avec $) se réalise, et l’évaluation des commandes (avec `) aussi.
$ Var="john"
$ echo $Var john
$ echo "$Var"
john
> Délimiteur antiquote `
Toute chaîne délimitée par antiquotes est interprétée comme une commande opérant sur des arguments :
o les valeurs des arguments sont évaluées o la commande est réalisée
o le résultat de la commande est substitué à la chaîne entre antiquotes
Ex : A la chaîne `date` sera substituée la chaîne Lun Oct 3 08:42:35 MET 2004
$ echo date date
$ echo "date"
date
$ echo `date`
Lun Oct 3 08:42:35 MET 2004
Attention, l’évaluation est récursive (le résultat de echo date est la chaîne date, qui est alors évaluée).
$ `echo date`
Lun Oct 3 08:42:35 MET 2004
Rappelons que pour toute commande, les arguments doivent être séparés par des espaces.
Les chaînes comportant des espaces doivent donc être délimitées par quotes ’ ou doublequotes ".
>> Calculs
Pour évaluer une expression arithmétique, il est nécessaire de faire appel à la commande expr.
> Syntaxe
expr [ argts]
Ex : $ expr 1 + 2 3
$ expr 2 + 3 \* 5 17
$ expr \( 2 + 3 \) \* 5 25
>> Arithmétique entière
Syntaxe Opération
Nbre1 + Nbre2 Somme Nbre1 – Nbre2 Différence Nbre1 \* Nbre2 Produit Nbre1 / Nbre2 Quotient Nbre1 % Nbre2 Reste
Lorsqu’un des opérandes n’est pas numérique, un message d’erreur est affiché.
Les expressions peuvent être combinées avec les parenthèses \( et \).
>> Incrément, décrément
Une variable NomVar doit être - incrémentée par
NomVar=`expr $NomVar + 1`
- décrémentée par
NomVar=`expr $NomVar – 1`
ATTENTION aux espaces autour de +, -, et aux métacaractères.
> Mécanisme d’incrémentation
NomVar=`expr $NomVar + 1`
Supposons que la valeur de NomVar soit actuellement 7.
1. le shell interprète d’abord le membre à droite de = 2. la chaîne entre antiquotes doit être évaluée
3. les arguments de expr sont donc évalués 4. à $NomVar est substitué l’entier 7
5. on évalue donc expr 7 + 1, qui retourne 8 6. 8 est alors substitué à la chaîne entre antiquotes 7. enfin, NomVar se voit assigner la valeur 8.
>> Décalage d’arguments
La commande shift permet de substituer à la liste des arguments d’un script la liste des arguments privée de son premier élément.
shift Nbre itère Nbre fois la commande shift Ex : #!/bin/bash
# testerShift
echo "liste des argts :" $*
shift
echo "après un shift :" $*
shift
echo "après deux shifts :" $*
echo ’$1’ "est maintenant :" $1 Exécutons : $ testerShift a b c
liste des argts : a b c après un shift : b c après deux shifts : c
$1 est maintenant : c
>> Fonctions
On a vu qu’on pouvait regrouper des séquences de commandes avec des accolades (de manière à exécuter des commandes dans le contexte courant).
On peut identifier une telle séquence par un nom NomFonc - function NomFonc {Com1 ; … ;}
- NomFonc() {Com1 ; … ;}
La commande return Nbre à l’intérieur d’une définition de fonction permet de retourner l’entier Nbre.
Les fonctions utilisent aussi les notations $1, $2, … pour leurs arguments.
>> Variables de position
Les paramètres d’une commande correspondant à un script sont aussi appelés variables de position.
On peut obtenir les valeurs des paramètres par ${Nbre} où Nbre est strictement positif.
Les accolades ne sont pas nécessaires pour les premiers arguments.
Rappel : $0 référence le nom de la commande.
Autres notations liées aux paramètres
Pour une commande correspondant à un script
- la valeur $* correspond à la liste des arguments
- la valeur $@ correspond à la liste des arguments (aucune différence avec le 1er si ce n’est pas entre doublequotes)
- la valeur $$ correspond au numéro de processus courant
- la valeur $! Correspond au numéro du plus récent processus exécuté en arrière plan.
>> Substitutions conditionnelles
On peut substituer une valeur à un identificateur de variable de manière conditionnelle.
${Var:-AutreChaîne}
=> si Var est définie et n’est pas la chaîne vide, l’expression ci-dessus vaut $Var, sinon elle vaut AutreChaîne
Ex : positionner automatiquement la variable TERM en cas de connexion depuis un terminal non graphique
$ TERM=`/usr/bin/termdef` ; echo TERM
$
$ TERM=${TERM:-vt100} ; echo TERM vt100
>> Expressions conditionnelles sur chaînes
Lorsqu’on a à effectuer des tests lexicographiques sur des chaînes, on doit utiliser une syntaxe particulière d’évaluation d’expression conditionnelle.
Cette syntaxe utilise des crochets doubles : [[ExprTest]]
ExprTest Expression conditionnelle vraie si Chaîne1 > Chaîne2 Supérieur lexicographique
Chaîne1 < Chaîne2 Inférieur lexicographique Ex : $ [["alain" > "albert"]] ; echo $?
0
$ [["albin" > "albert"]] ; echo $?
1
>> Classes de caractères
Les intervalles de caractères de type a-z ne fonctionnent pas de même manière sur toutes les configurations. Pour une meilleure portabilité des scripts, il vaut toujours mieux utiliser les notations de classes.
La notation [[:LaClasse:]] s’identifie à 1 caractère de la classe désignée.
[:digit:] chiffres décimaux, équivaut à 0-9 [:xdigit:] chiffres hexadécimaux
[:cntrl:] caractères de contrôles [:print:] caractères imprimables [:upper:] lettres majuscules [:lower:] lettres minuscules
[:alpha:] lettres majuscules ou minuscules [:alnum:] lettres ou chiffres décimaux [:space:] espaces et tabulations [:punct:]
caractères de ponctuation (sauf le . placé en premier caractère ou après un /)
COMPLEMENTS SUR L’ENVIRONNEMENT
>> Variables d’environnement
Les variables d’un processus shell peuvent être divisées en deux catégories
- les variables locales au shell dont les applications lancées depuis ce shell ne peuvent connaître la valeur
- les variables dites d’environnement ou exportées qui sont transmises aux applications lancées depuis le shell
Une variable NomVar peut devenir une variable exportée via la commande export NomVar.
>> Variables locales et d’environnement
La liste des variables locales au shell est obtenue au moyen de la commande set.
La liste des variables d’environnement est obtenue au moyen de la commande env.
Les variables d’environnements les plus courantes sont
PWD HOME PATH PS1 TERM SHELL USER HOSTNAME LOGNAME MAIL
>> Exportation
$ VarExportee="VE" ; export VarExportee
$ VarNonExportee="VNE"
$ echo $LOGNAME $ VarExportee $VarNonExportee john VE VNE
On considère le script afficherVariables
#!/bin/bash VarLocale="VL"
echo $LOGNAME $VarExportee $VarNonExportee echo $VarLocale "fin_script"
$ afficherVariables john VE
VL fin_script
$ echo $VarLocale
$
>> Manipulation des variables
typeset ±Options NomVar=Valeur
(+ pour attribuer, - pour désactiver), permet d’affecter une valeur ainsi qu’un attribut.
Option Attribut
i Variable de type entier
l Majuscules transformées en minuscules r Variable accessible seulement en lecture u Minuscules transformées en majuscules x Variable exportée
unset NomVar : supprime la définition de la variable NomVar
>> Initialisation de l’environnement
Il y a deux niveaux d’initialisation de l’environnement - un shell de login examine
o le fichier /etc/profile (environnement public)
o puis un fichier du répertoire privé de l’utilisateur (environnement privé)
$HOME/.bash_profile,à défaut
$HOME/.bash_login, à défaut
$HOME/.profile
et s’il trouve un fichier lisible, il exécute les commandes qui s’y trouvent.
Ensuite, ce shell de login se comporte comme tout autre shell.
- un shell qui n’est pas de login examine le fichier $HOME/.bashrc et exécute les commandes qui s’y trouvent
>> Lors de l’exécution d’un script
Si la variable BASH_ENV est définie (ie a été définie par un shell de login), et s’il existe un fichier référencé par BASH_ENV, ce fichier (généralement $HOME/.bashrc) est interprété par le shell.
>> Définition de synonymes
Il est possible de définir des alias de commandes.
Syntaxe :
alias NomAlias=Chaîne
On peut visualiser la valeur d’un alias par alias NomAlias et tous les alias en cours par alias.
Enfin, on peut retirer un alias par unalias NomAlias.
> Fichier d’alias
Généralement, les définitions d’alias sont regroupées dans un fichier à chaque ouverture de shell interactif, par exemple un fichier $HOME/.bashrc.
Exemple d’alias :
alias rm=’rm –i’
alias mv=’mv –i’
alias cd..=’cd ..’
>> Le répertoire utilisateur
Référencé par $HOME. /!\ $PWD
>> Chemin de recherche des commandes
La variable d’environnement PATH désigne le chemin de recherche des commandes, et a pour valeur une liste des répertoires séparés par des :.
$ echo $PATH
/usr/bin:/usr/local/bin:/home/johndoe/bin
Lorsqu’on invoque une commande LaCommande, le shell cherche successivement dans chacun des répertoires listés dans $PATH s’il existe une commande de nom LaCommande. Dès qu’il la trouve, il l’exécute.
> Recherche de commande
Il peut arriver que deux commandes de même nom LaCommande soient présentes dans deux répertoires distincts référencés par $PATH.
On peut savoir laquelle sera exécutée which LaCommande
indique la référence absolue de LaCommande
$ which ls /usr/bin/ls
> Modifier le chemin de recherche Modification de PATH :
PATH=$PATH:$HOME/bin
/!\ L’ordre d’écriture est TRES important !
L’écriture PATH=$HOME/bin:$PATH est plus dangereuse, puisqu’un faux ls placé dans le répertoire $HOME/bin permet de court-circuiter le vrai ls.
Il est commode de placer le changement de PATH dans $HOME/.profile.
LES EXPRESSIONS REGULIERES
>> Expressions régulières (ou rationnelles)
Permettent de décrire des ensembles de motifs (ou mots). Ces expressions régulières sont ensuite utilisées par un certain nombre de commandes (grep, ed, sed, vi, expr) qui les reconnaissent.
Elles sont aussi utilisées hors du monde Unix par certaines applications (construction de filtres dans des systèmes de courrier Eudora par exemple).
>> Les caractères spéciaux
Susceptibles d’avoir en certaines circonstances une interprétation particulière à l’intérieur d’une expression régulière.
Ex : [.* sont spéciaux SAUF lorsqu’ils figurent dans la liste des caractères définissant un ensemble de caractères ([~~~]).
Ex : [.*[!:]
Qui désigne l’un des caractères [ . * ! :.
- Le caractère [ est l’indicateur de début de la définition d’un ensemble de caractères.
- Le caractère . désigne un caractère quelconque excepté le caractère de fin de ligne.
- * indicateur d’itération d’un nombre quelconque de fois, sauf en premier caractère d’une expression ou directement après une séquence \) ouvrant la définition d’un champ.
Les caractères suivants ont une interprétation spéciale dans les contextes particuliers indiqués.
- Le caractère ] indique la terminaison de la définition d’un ensemble de caractères (cette définition ayant commencé à l’occurrence précédente et la plus externe de [).
- Le caractère – permet, dans une définition d’ensemble, de spécifier l’intervalle de tous les caractères compris entre le caractère précédent et le caractère suivant – dans l’expression.
Le caractère – n’est plus spécial s’il suit immédiatement le caractère [ ou précède le ] (début et fin de définition d’ensemble).
Ex : [-a -d] équivaut à [-abcd]
- Le caractère ^ signifie
o Le début de ligne lorsqu’il est en début d’expression
o Le complément ensembliste lorsqu’il suit immédiatement un caractère [ de début de définition d’ensemble.
- Le caractère $ signifie la fin de ligne lorsqu’il est le dernier caractère d’une expression.
- Le caractère \ précédant un caractère spécial lui enlève son interprétation particulière (sauf à l’intérieur de la définition d’un ensemble).
Ex : ^\. ou ^[.] désigne une ligne commençant par .
>> Expressions régulières atomiques
= 1 seul caractère
Différentes expressions régulières :
- Caractère non spécial quelconque : l’ensemble correspondant ne contient que le mot de 1 caractère correspondant.
- Caractère spécial précédé du caractère \
- Caractère spécial . : tout motif de 1 caractère, quel qu’il soit, sauf le caractère de fin
de ligne.
- Suite de caractères entre [ et ] ne commençant pas par ^ : tout motif constitué de 1 caractère de la suite appartient à l’ensemble défini par l’expression.
- Idem commençant par ^ : tout motif caractère n’appartenant pas à la suite appartient à l’ensemble de motifs défini.
- Une expression de la forme [:LaClasse:] définit de manière symbolique une classe de caractères. Pour décrire un élément de la classe, on utilise la notation [[:LaClasse:]]
>> Expressions régulières générales Elles ont les formes suivantes :
- Régulière atomique.
- Régulière atomique suivie du caractère *.
Définit l’ensemble de longueur positive ou nulle pouvant être construit sur l’alphabet défini par cette expression atomique.
- Une concaténation (ie mise bout à bout) de deux expressions régulières.
- Toute expression dont le 1er caractère est ^ indique que les motifs désignés doivent être en début de ligne
- Toute expression dont le dernier caractère est $ indique que les motifs désignés doivent être en fin de ligne.
- Une expression comprise entre \( et \)
Cette notation est équivalente à l’expression régulière elle-même, c'est-à-dire utilisée sans \( et \).
• Son intérêt est de fournir un moyen de repérage et de désignation (voir suite)
• Il est ainsi possible de définir des sous expressions d’une expression Ex : \[.*\) vaut pour une chaîne de caractères quelconques (un motif)
- \Nbre désigne dans une expression le motif (ie le mot appartenant à l’ensemble défini par cette expression) de la Nbre-ième sous expression (définie par le mécanisme de parenthésage décrit précédemment) de l’expression complète.
Ex : \(.*\)\1\1 désigne les objets obtenus par double concaténation du motif numéro 1 à lui-même (mots triples) (motif 1 = \(.*\))
Quelques règles :
Nbre doit être compris entre 1 et 9
Dans le cas où Nbre est suivi du caractère *, la sous expression peut être itérée un nombre quelconque de fois (0 ou plus)
- une expression régulière atomique suivie de
o \{Nbre\} indiquant Nbre occurrences consécutives de caractères de l’ensemble défini par l’expression atomique donnée
o \{Nbre,\} indiquant un nombre minimal de Nbre occurrences consécutives de caractères de l’ensemble défini par l’expression atomique donnée
o \{Nbre1,Nbre2\} indiquant un nombre minimal de Nbre1 et un nombre maximal de Nbre2 occurrences consécutives de caractères de l’ensemble défini par l’expression atomique donnée.
(entre 0 et 255) Ex :
- ^\..*$ ou ^\. ou ^[.]*$ ou ^[.]
Désigne les lignes qui commencent par . - [a-zA-Z0-9]
Est l’ensemble de tous les caractères alphanumériques (équivalent dans la plupart des cas à [[:alnum:]]).
- [^a-zA-ZO-9]
Est l’ensemble complémentaire du précédent (ni une lettre majuscule, ni une lettre minuscule, ni un chiffre).
- [-^[]
Est l’ensemble des 3 caractères – [ et ^ - ^[a-z]*$
Désigne les lignes qui sont vides ou bien qui ne contiennent que des lettres minuscules.
- ^[a-z]\{3\}[^a-z]\{3\}$
Désigne les lignes qui commencent par 3 lettres minuscules et finissent par 3 caractères qui n’en sont pas et ne contiennent aucun autre caractère.
- ^[(.*\)\1\1$
Désigne l’ensemble des lignes qui sont obtenues par double concaténation d’un motif à lui- même (mots triples).
- ^.*[[:space:]].*$
Désigne les lignes qui contiennent au moins un espace ou une tabulation.
- ^.*[[:space:]]\{3\}.*$
Désigne les lignes qui contiennent au moins un bloc de 3 espaces / tabulations.
- ^[[:space:]][[:space:]]*$
Désigne les lignes qui ne contiennent que des espaces ou tabulations (mais au moins un).
- $[[:space:]]*$
Pareil mais éventuellement aucun (=ligne vide).
- ^[[:upper:]]\{10,\}.*$
Désigne les lignes qui contiennent en début de ligne au moins 10 lettres majuscules consécutives.
- ^\(ab\)\{2\}.*$
Désigne les lignes qui contiennent deux répétitions du motif ab en début de ligne.
- ^.*\(ab\)\{2\}$
Même chose en fin de ligne.
- ^\(ab\)\{2\}.*\(ab\)\{2\}$
Désigne les lignes qui contiennent 2 répétitions du motif ab en début et fin de ligne.
On souhaite envoyer directement à la poubelle les mails provenant des adresses qui compteront au moins 4 chiffres consécutifs.
On peut sélectionner ces adresses au moyen de l’expression régulière
^.*[[:digit:]]\{4\}.*$
LES SYSTEMES DE FICHIERS PRINCIPE D’ORGANISATION
>> Notion de fichier
En Unix, la notion de fichier ne se limite pas à la simple notion de fichier disque.
Fichier = objet typé dont le type permet de définir l’ensemble des opérations qui peuvent lui être appliquées.
Un fichier pourra
- correspondre à un fichier disque au sens classique du terme
- être associé à une ressource (physique ou logique) du système (device) comme o les terminaux
o les imprimantes o les disques physiques
o les disques logiques (partitions)
o la mémoire physique (=kernel memory) (contient les tables du noyau)
>> i-nœuds
A chaque fichier correspond une entrée dans une table contenant l’ensemble des attributs de ce fichier (par exemple son type, ses propriétaires ou ses droits d’accès).
Une telle entrée est appelée i-nœud (i-node ou index node).
>> Identification d’un fichier
Un fichier a pour identification un couple constitué de :
- l’identification de la table dans laquelle sont enregistrées ses caractéristiques (disque logique organisé en système de gestion de fichiers)
- l’indice dans cette table de l’entrée contenant ces caractéristiques. Cet indice peut être affiché avec ls –li.
>> Le type d’un fichier
Le type définit l’ensemble des opérations (et la sémantique de chacune d’elles) qui peuvent être réalisées sur le fichier.
L’accès aux fichiers des différents types est réalisé au travers d’un ensemble de primitives système (points d’accès dans le noyau), de noms génériques (par exemple open, read, write et close).
Le système se charge, à partir du type d’un fichier et des informations contenues dans le nœud associé, d’appeler les fonctions spécifiques correspondant à l’objet particulier.
Souplesse du concept de fichier
Cette propriété permet de développer des applications sur des fichiers capables de s’adapter aux différents types de fichiers.
Cette souplesse du concept de fichier UNIX est illustrée par les mécanismes de redirection des processus Shell qui peuvent être utilisés par exemple aussi bien sur des fichiers sur des disques que sur des terminaux.
>> Catégories de fichiers
En première approximation, on peut classifier les différents types de fichiers en 2 grandes catégories selon qu’ils ont
- un contenu sur disque (fichiers réguliers, répertoires, liens symboliques, tubes) - pas de contenu sur le disque (fichiers spéciaux correspondant à des ressources).
>> Répertoires
Les répertoires jouent un rôle privilégié car leur contenu est interprété par un certain nombre de fonctions du système.
- Ils permettent de structurer l’ensemble des fichiers en arborescence
- Ils définissent un mécanisme de désignation extérieure des fichiers
indépendamment de leur localisation dans les tables du système et sur le disque.
Comment savoir si un identificateur correspond à un répertoire ?
Les répertoires sont détectés au moyen de la commande ls –l
Le 1er caractère de la ligne correspondant à l’identification du répertoire étant un d.
$ ls –l
-rw---- bash.pdf drwxr-x TDsys/
drwx--- tmp/
>> Référençage
Le mécanisme de référençage repose sur l’association réalisée dans les répertoires entre - chaînes de caractères (appelées liens physiques)
- n° d’index des fichiers
La désignation extérieure d’un fichier est réalisée
- en utilisant un lien associé à ce fichier dans un répertoire
- ce répertoire étant lui-même désigné par le même mécanisme dans un autre répertoire
L’origine symbolique de cette arborescence est appelée racine absolue du système de gestion de fichiers.
>> Organisation des arborescences
En fait, il n’y a pas une table des fichiers mais plusieurs, chacune correspondant à une arborescence indépendante.
La racine de chacune de ces arborescences a le n° 2 comme n° d’index dans la table correspondante.
Les différentes arborescences peuvent être reliées entre elles par le mécanisme de montage : ce mécanisme permet de greffer la racine d’une arborescence non encore montée, en un point accessible depuis la racine absolue.
>> Montage
L’une des arborescences, correspondant au disque système, est privilégié car - les montages des autres se font par rapport à elle
- sa racine est la racine absolue du système de gestion de fichiers complets.
Le mécanisme de montage repose sur le fait que
- chaque disque logique constitue une ressource (logique) du système
- et donc c’est un fichier spécial qui possède un lien dans un répertoire particulier du disque système (le répertoire des ressources).
> Montage distant
Le mécanisme de montage peut être étendu afin de permettre l’accès aux fichiers appartenant à des systèmes distants de manière transparente.
Le protocole le plus répandu qui autorise de tels accès est le protocole NFS (Network File System).
LES REFERENCES
>>Fichiers accessibles et chemins d’accès Fichiers accessibles à un instant donné :
- ceux du disque système (toujours monté)
- ceux qui appartiennent à un disque logique dont la racine à été montée relativement
au disque système.
Il existe au moins un chemin de la racine vers ce fichier.
>> Références absolues
/home/Etud/IQ1/Letudiant/TDsys/couperSansVerif Cette suite constitue un chemin d’accès (référence absolue).
>> Répertoires de travail
Répertoire privilégié (répertoire courant) par rapport auquel il est impossible de réaliser des repérages relatifs.
>> Références relatives
Désignation par rapport à un répertoire de travail.
Suite de liens séparés par / qui ne commence pas par / Référence absolue : $PWD/couperSansVerif.
=> se déduit de la référence relative.
>> Les liens .. et .
.. correspond au répertoire parent . désigne le répertoire lui-même
>> Répertoires (presques) vides
Un répertoire Unix n’est jamais totalement vide : il contient au moins 2 liens physiques : . et ..
>> Répertoire privé
(home directory) $HOME
Devient automatiquement le répertoire de travail du processus shell lancé à sa connexion au système (opération login).
Il est visible dans /etc/passwd.
grep "LeNom" /etc/passwd | cut –d’:’ –f6
LES DIFFERENTS TYPES DE FICHIERS
>> Les fichiers ordinaires ou réguliers
Fichiers sur disque dont le contenu est non structuré le contenu correspond à une suite de caractères caractérisé par sa longueur (permet en particulier de détecter la fin du fichier).
Longueur obtenue par wc –c.
Les contenus peuvent être programmes (binaires ou sources)
données de programmes utilisateurs ou systèmes.
résultats de programmes (éditeurs de textes, compilateurs…).
>> Les répertoires usuels
C’est par leur intermédiaire que les utilisateurs peuvent désigner leurs fichiers.
Sur tous les systèmes :
/bin et /usr/bin contiennent les noms des commandes Unix non internes aux différents langages de commandes.
/usr/lbin ou /usr/local/bin contiennent les noms des commandes particulières à un site donné.
/dev contient les noms de fichiers spéciaux associés aux ressources.
/etc contient les noms de fichiers systèmes.
/tmp contient les références de fichiers temporaires utilisés par les applications système.
