1. Plan du cours
2. Fonctionnalités Générales
3. Les Shells
4. Comparaison des Shells
5. Algorithme du shell
6. Caractères de contrôle au clavier
7. Format d'une commande
8. Pipelines, Listes
9. Enchaînement de commandes
10. Les entrées-sorties
11. Redirection des entrées-sorties
12. Méta-caractères d'expansion
13. Variables d'environnement prédéfinies
14. Variables de substitution prédéfinies
15. Variables utilisateur
16. Instructions conditionnelles
17. Instructions de boucle
18. Instructions de rupture de boucle
19. Instructions d'aiguillage
20. Expansion de commande
21. Expansion de paramètre
22. Quotage
23. Déroutements
24. Commandes internes au Shell
25. Commandes de test
26. Arithmétique
27. Fonctions
28. Fichier de commande, Script
29. Fichiers d'initialisation
30. /etc/profile
31. (sous System V uniquement)
32. .profile
33. .zshrc, .bashrc
34. (en zsh ou bash uniquement)
35. .login, .cshrc, .tcshrc, .logout
36. (en csh ou tcsh uniquement)
37. Fonctionnalités spécifiques ENST
38. Schéma de fonctionnement
39. Personalisation de l'environnement

Plan du cours

• Description générale

• L'interpréteur de commandes
  • lancement d'une commande
  • redirection des entrées/sorties
  • enchaînement des commandes et pipelines
  • méta-caractères d'expansion
  • variables prédéfinies

• Programmation en shell
  • fichier de commandes, shell-script
  • variables formelles
  • variables utilisateur, exportation et héritage
  • instructions de contrôle
  • substitutions
  • quotage et évaluation
  • déroutements
  • commandes internes
  • arithmétique en shell
  • fonctions
  • fichiers d'environnement et spécificités ENST

Fonctionnalités Générales

• Processus premier d'une session
  • user:password:uid:gid:comment:homedir:shell
  • attaché au terminal console (login) ou à un pseudo-terminal (remote login, activation d'une fenêtre)
  • xterm (X11), cmdtool et shelltool (openwin)
• Interpréteur de commandes
  • lecture et exécution de commandes
  • redirection des entrées/sorties
  • expansion des noms de fichiers
  • interface utilisateur (historique, aliasing, contrôle des jobs, complétion, édition de lignes de commandes.
• Langage de programmation
  • programmation interactive (en ligne)
  • programmation non-interactive (fichier de commandes)
  • intructions conditionnelles et itératives, fonctions
  • variables prédéfinies et variables utilisateur
  • mécanismes de substitution de paramètres
  • commandes internes (builtin)

Les Shells

• sh ("Bourne shell", Steve Bourne)
  • shell historique (disponible sur tous les Unix)
• csh ("C-shell", Bill Joy)
  • shell BSD (disponible sur tous les Unix)
• ksh ("Korn shell")
  • shell normalisé POSIX (P1003.2) et ISO (HP, Solaris)
• bash ("Bourne again shell" de Brian Fox et Chet Ramey)
  • Ksh du domaine public (installé sur toutes les machines)
• zsh ("Zero shell")
  • Ksh du domaine public (installé sur toutes les machines)
• tcsh ("Toronto C-shell")
• rc (Plan9, Tom Duff)

Comparaison des Shells

Shell       progr       jobs        histo       aliases     édition     flèche      extens    
                                                            ligne 
                  POSIX 
       
sh          std         non         non         non         non         non         non         
csh         non std     oui         oui         oui         non         non         non         
tcsh        non std     oui         oui         oui         oui         oui         non         
ksh         norme       oui         oui         oui         oui         non         non         
bash        norme       oui         oui         oui         oui         oui         non         
zsh         norme       oui         oui         oui         oui         oui         oui         
                                                                                          

Shell           interface utilisateur                programmation
                        
sh              inexistante                          sûre (standard)                      
csh             moyenne                              à déconseiller                       
tcsh            bonne                                à déconseiller                       
ksh             bonne                                normalisée                           
bash            bonne                                normalisée                           
zsh             excellente                           normalisée + extensions              

Algorithme du shell

• Ouverture initiale de 3 fichiers standard
  • entrée standard (stdin, fd=0), par défaut le clavier
  • sortie standard (stdout, fd=1), par défaut l'écran
  • sortie erreur standard (stderr, fd=2), par défaut l'écran
• Le shell lit sur son entrée standard
  • lecture de la commande jusqu'à la fin de ligne (\n) et interprétation des métacaractères et opérateurs
  • lecture des lignes de commandes jusqu'à la fin de fichier (^D)
• Lancement d'une commande
  • recherche du nom de la commande à l'aide du PATH (path)
  • en premier plan : fork() exec(commande) wait() prompt
  • en arrière plan : fork() exec(commande) prompt

Caractères de contrôle au clavier

• Caractères de contrôle non gérés par le shell
  • <cr> fin de ligne (retour chariot) mappé en <cr><lf>
  • <lf> fin de ligne (nouvelle ligne) mappé en <cr><lf>
  • <tab> tabulation
  • <bs> ^H, backspace, effacement du caractère précédent
  • <del> ^?, souvent identique à <bs>
  • <^C> interruption d'un processus attaché au terminal
  • <^\> arrêt d'un processus avec vidage mémoire (core)
  • <^Z> suspension d'un processus en premier plan
  • <^U> effacement de la ligne complète
  • <^W> effacement du mot qui précède
  • <^D> fin de fichier => si le shell lit, fin d'un shell
  • <^S> suspension de l'affichage écran (Xoff)
  • <^Q> reprise de l'affichage écran (Xon)
• Gestion des caractères de contrôle par stty
  • stty erase ^H kill ^U intr ^C susp ^Z quit ^\ eof ^D

Format d'une commande

• Métacaractères
  • | & ; ( ) < > <espace> <tab>
• Opérateurs de contrôle
  • || & && ; ;; ( ) | <newline>

Format d'une commande

• Invite (le prompt) principale
  • $ en mode utilisateur
  • # en mode super-utilisateur
  • <user@host: num> défini tel quel à l'ENST
  • variable PS1
• Invite secondaire
  • > en mode interactif
  • variable PS2
• Commande simple
  • une commande simple est une séquence de mots séparés par un séparateur blanc et de redirections. Le premier mot désigne le nom de la commande à exécuter, les mots suivants sont passés en arguments à la commande.
  • la valeur retournée d'une commande est celle de son exit.
• Chemin de recherche du nom d'une commande : PATH ou path (csh)
  • PATH=/usr/ucb:/bin:/usr/bin:/usr/local/bin:~/bin:.

Pipelines, Listes

• Pipeline
  • un pipeline est une séquence d'une ou plusieurs commandes séparées par le caractère |.
  • format : [!] command1 [ | command2 ... ]
  • la sortie standard de la première commande est connectée à l'entrée standard de la commande suivante, et ainsi de suite.
• Liste
  • une liste est une séquence d'un ou plusieurs pipelines séparés par un des opérateurs : ;, &, &&, ||.
  • une liste est optionnellement terminée par un ;, &, <newline>.
  • précédences des opérateurs: && > || > ; = &
  • si une commande est terminée par l'opérateur &, ls shell exécute la commande un arrière plan (backgroud)dans un sous-shell.
  • les commandes séparées par un ; sont exécutées séquentiellement, le shell attend la fin de chaque commande.

Enchaînement de commandes

• Commande simple (en premier plan)
  • $ commande [ arg ... ]
• Commande simple (en arrière plan)
  • $ commande [ arg ... ] &
• Pipeline (tube de communication)
  • $ commande1 [ arg ... ] | commande2 [ arg ...] | ...
• Séquencement de commandes (en premier plan)
  • $ commande1 [ arg ... ]; commande2 [ arg ... ]; commande3 ...
• Exécution par un nouveau shell ()
  • $ sh commande [ arg ... ]
  • $ (commande [ arg ... ])
  • $ (commande [ arg ... ]) &
• Regroupement de commandes
  • $ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)
  • $ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)&

Les entrées-sorties

• Interruptions clavier
  • <^C> interruption d'un processus attaché au terminal
  • <^\> arrêt d'un processus avec vidage mémoire (core)
  • <^Z> suspension d'un processus en premier plan

Redirection des entrées-sorties

• Fichiers standard
  • entrée standard (stdin, fd=0), par défaut le clavier
  • sortie standard (stdout, fd=1), par défaut l'écran
  • sortie erreur standard (stderr, fd=1), par défaut l'écran
• Redirection de l'entrée standard
  • < fichier ou périphérique
  • <<marque texte qui suit jusqu'à la marque (here documents)
• Redirection de la sortie standard
  • > fichier ou périphérique
  • 1> fichier ou périphérique
  • >> fichier ou périphérique (en ralongement)
• Redirection de la sortie erreur standard
  • >& &> fichier ou périphérique
  • 2> fichier ou périphérique
• Autres redirections
  • <> fichier ou périphérique (en mise à jour)

Redirection des entrées-sorties

• Exemples
  • cat fichier1 >fichier2 copie
  • cat fichier3 >>fichier2 ajout
  • cat >fichier4 saisie de texte
  • cat <fichier4 listage
  • cat <fichier4 >fichier5 copie
  • cat <fichier6 >>fichier5 ajout
  • cat <<!EOF >fichier7 copie
    ligne1
    ligne2
    ...
    autres lignes
    !EOF

  • rm *.o *% *~ core >& /dev/null nettoyage silencieux
    
  • appli 1>/dev/null 2>&1 & silence total en background

Méta-caractères d'expansion

• Expansion des noms de fichiers
  • Ne pas confondre avec les caractères spéciaux des expressionsrégulières. Ne sont concernées que les chaînes de caractères des noms de fichiers.
  • * remplace n'importe quelle chaîne de caractères

    micro*
    microprocesseur micro-ordinateur microcosme
    ? remplace n'importe quel caractère
    m?cro
    micro macro
    

  • [...] établit une coïncidence avec l'un des caractères mis entre crochets m[ai]*
    mail macro micro mini
    

  • [.-.] établit une coïncidence avec tous les caractères compris entre les 2 bornes

    ls [A-Z]*.[hc1-8]
    Prog.c Include.h Data.1 Text.6
    

  • {...,...} remplace successivement les chaînes intérieures

    ls *.{C,cc}
    

  • ~ remplace par le $HOME ou celui d'un autre login (csh, bash).

    cd ~username

Variables d'environnement prédéfinies

• HOME chemin d'accès au répertoire initial de l'utilisateur
• PATH suite de chemins d'accès aux répertoires des exécutables
• PS1 invite principale du shell en mode interpréteur
• PS2 invite secondaire du shell en mode programmation
• IFS séparateurs de champ des arguments
• MAIL chemin d'accès à la boîte aux lettres utilisateur
• MAILCHECK intervale en sec au bout duquel le mail est contrôlé
• CDPATH liste de chemins d'accès pour la commande cd
• ENV nom du fichier des variables d'environnement
• TERM nom du type de terminal

Variables de substitution prédéfinies

• $0 nom du script (pathname)
• $1, ..., $9 arguments (du 1er au 9ème)
• $# nombre d'arguments
• $* liste de tous les arguments
• $@ liste de tous les arguments
• $? code retourné par la dernière commande
• $$ numéro de processus de ce shell
• $! numéro du dermier processus en arrière plan
• $- drapeaux fournis au shell par set

Variables utilisateur

• Déclaration
  • variable=valeur
• Utilisation
  • variable2=$variable
  • variable2=${variable}
• Exportation
  • export variable
  • variable=valeur export variable (sh)
  • export variable=valeur (bash, zsh)

• Exemple

  EXINIT='set nu ai ic' 
  export EXINIT 
  EXINIT='set nu ai ic' export EXINIT
  

Instructions conditionnelles

• Condition simple: if then ... fi

  if commande ; then
  liste de commandes
  fi

• Condition avec alternative: if then ... else ... fi

  if commande ; then
  liste de commandes
  else
  liste de commandes
  fi

• Condition multiple: if then ... elif then ... fi

  if commande ; then
  liste de commandes
  elif commande ; then
  liste de commandes
  else
  liste de commandes
  fi

Instructions de boucle

• Boucle for: for in do ... done

  for variable [ in liste d'arguments ]
  do
  liste de commandes
  done

• Boucle while: while do ... done

  while commande
  do
  liste de commandes
  done

• Boucle until: until do ... done

  until commande
  do
  liste de commandes
  done

Instructions de rupture de boucle

• continuation de boucle: continue [n]
  • revenir au début de la boucle for, while, until
  • n = niveau de boucle à partir de la boucle la plus externe

    for var1 in ${liste1} 
    do
        for var2 in ${liste2}
        do
            if cmd2 ; then
                continue 2
            fi
        done 
    done
    

• Sortie de boucle : break [n]
  • sortir d'une ou n boucles for, while, until
  • n = niveau de boucle à partir de la boucle la plus externe
• Sortie de programme: exit n
  • sortir d'un script-shell avec un code de retour (n)

Instructions d'aiguillage

• Aiguillage case: case in ... esac

  case $variable in
  motif1) liste de commandes ;;
  motif2) liste de commandes ;;
  *) liste de commandes ;;
  esac

• Exemple :

  case $# in 
  1)	 arg1=$1;; 
  2)	 arg1=$1; arg2=$2 ;; 
  0)	 echo "usage: $0 arg1 [ arg2 ]
  		exit 1;; 
  esac
  

Expansion de commande

• Expansion de commande
  • variable=`commande`
  • variable=$(commande)
• Exemple

  date=`date +%d/%m/%y %H:%M` 
  scriptname=$(basename $0)
  

Expansion de paramètre

• Expansion de paramètre
  • variable=${var:-val} si var est définie ou non nulle alors var sinon val
    
  • variable=${var:=val} si var est définie ou non nulle alors var sinon affecte val
    
  • variable=${var:?mess} si var est définie ou non nulle alors var sinon affichage du message mess
    
  • variable=${var:+val} si var est définie ou non nulle alors val sinon rien n'est substitué
    
  • variable=${#var} longueur en octet de la chaîne var
    
  • variable=${var#str} supprime en début de var la plus petite chaîne parmi les 2
    
  • variable=${var##str} supprime en début de var la plus grande chaîne parmi les 2
    
  • variable=${var%str} supprime en fin de var la plus petite chaîne parmi les 2
    
  • variable=${var%%str} supprime en fin de var la plus grande chaîne parmi les 2

• Exemple

  cd ${dir:-$HOME} 
  for f in *.C		# renommage des *.C en *.cc 
  do
      g=${f%.C}
      mv $f $g.cc 
  done
  

Quotage

• Rôle
  • le quotage est utilisé pour supprimer les fonctionnalités de certains caractères spéciaux du shell, dont les métacaractères.
• Méta-caractères
  • \ $ * ` " '
• Caractère d'échappement \
  • le caractère \ préserve la valeur littérale du caractère qui le suit immédiatement.
• Simples quotes '...'
  • les caractères inclus entre 2 simples quotes ne sont pas évalués, ils conservent leur valeur littérale.
• Doubles quotes "..."
  • les caractères inclus entre 2 doubles quotes conservent leur valeur littérale à l'exception de $ ` et \.

• Exemple
  echo "usage: `basename $0` '$DISPLAY'"

Déroutements

• Séquence d'exception
  • trap 'liste de commandes'liste de signaux

    Exemple :

    trap 'rm /tmp/appl.$$; exit 1' 2

• Ignorance des signaux
  • trap 'l' liste de signaux

    Exemple :

    trap '' 1 2 3 15

• Réinitialisation
  • trap liste de signaux

    Exemple :

    trap 2 3

• Liste des signaux
  • trap

    Exemple :

    trap

Commandes internes au Shell

• :
• . filename
• alias [nom[=commande] ...]
• bg [jobnum]
• cd [dir]
• echo [-ne] [arg ...]
• eval [arg ...]
• exec [[-] commande[arg ...]]
• exit [n]
• export [variable ...]
• fg [jobnum]
• job [jobnum]
• kill [-signal] [pid|jobnum]
• popd
• pushd [dir]
• pwd
• read [variable ...]
• readonly [variable ...]
• return [n]
• set [-aefhknotuvxldCH] [arg ...]
• shift [n]
• test expression
• times
• trap [arg] [signaux]
• type [-all|-type|-path] [commande]
• ulimit [-SHacdfmstpn [limite]]
• umask [mode]
• unalias [nom ...]
• unset [variable ...]
• wait [pid|jobnum]

Commandes de test

• test sur les fichiers
  • test -f fichier, test -d fichier, test -s fichier
  • test -r fichier, test -w fichier, test -x fichier

    Exemple : if [ ! -d repert ]; then mkdir repert ; fi

• Comparaisons alphanumériques
  • test "$str1" = "chaine1"
  • test "$str1" != "chaine1"
  • test "$str1" > "chaine1"
  • test "$str1" < "chaine1"
  • test "$str1" >= "chaine1"
  • test "$str1" <= "chaine1"
• Comparaisons algébriques
  • -eq -ne -gt -lt -ge -le
• Comparaisons booléennes
  • -z -n
• Autres opérateurs
  • ! -a -o

Arithmétique

• Commande Unix expr
  • expr val1 oper val2
  • opérations : +, -, *, /, %
  • utilisation : substitution de commande en sh
  • peut performant : nécessite un fork()-exec()
• Commande Shell (ksh, bash, zsh)
  • $[expression]
  • interne au shell -> performant
• Exemple

  #!/bin/sh 
  while true; do
      compteur=`expr $compteur + 1` 
  done
  
  #!/usr/local/bin/zsh 
  while true; do
      compteur=$[$compteur + 1] 
  done
  

Fonctions

• function
  syntaxe: [function] nom() {.........}
  • appel de fonction: nom [arg ...]
  • pas de déclaration d'arguments entre parenthèses ()
  • les fonctions doivent être définies avant leur utilisation
• Exemple

  #!/bin/sh 
  # 
  # Exemple de script avec fonctions 
  usage() 
  {
    		echo "usage: $1 $2" 
  } 
  main() 
  {
      if [ $# = 0 ]; then
          usage `basename $0` "fichier";
          exit 1
      fi 
  } 
  main $*
  

Fichier de commande, Script

• Magic number
  • première ligne : #! /bin/sh
• Commentaires
  • #

• Exemple

  #!/usr/local/bin/bash 
  # 
  # Essai de script 
  # 
  PATH=$PATH:/usr/local/bin; export PATH
  
  usage() 
  {
      echo "usage: $1 $2" 
  } 
  main() 
  {
      if [ $# = 0 ]; then
          usage `basename $0` "fichier";
          exit 1
      fi 
  } 
  main $*
  

Fichiers d'initialisation

• /etc/profile
• .profile
• .login
• .cshrc
• .logout
• .bash_profile
• .bashrc
• .bash_alias
• .inputrc
• .zshrc
• .tcshrc

/etc/profile (sous System V uniquement)

• Initialisation commune à tous les login-shells
  • point de passage obligé pour tous les login
  • est remplacé à l'ENST par /usr/local/startup/profile
  • variables d'environnement à très longue durée de vie
  • fourni par le constructeur / adapté par l'administrateur
  • non modifiable par l'utilisateur
• Exemple

  umask 027 
  USER=`logname` 
  PATH=/usr/local/bin:/usr/ucb:/bin:/usr/bin:/usr/X11/bin 
  MANPATH=/usr/local/man:/usr/man:/usr/lang/man 
  MAIL=/usr/spool/mail/$USER 
  HOSTNAME=`uname -n` 
  OS=`uname -s` 
  REL=`uname -r` 
  OSREL=${OS}${REL} 
  export USER PATH MANPATH MAIL HOSTNAME OS REL OSREL
  

.profile

• Initialisation propre à l'utilisateur
  • situé dans le HOME de l'utilisateur : ~/.profile
  • redéfinition des variables proposées par /etc/profile
  • définition de nouvelles variables (var=valeur)
  • détection si le shell est interactif ou non
  • exécution ou non de scripts d'initialisation
  • configuration des paramètres du terminal (stty)
  • peut-être "ressourcé" (. ou source) . profile (sh, ksh, bash, zsh)

    source .profile (bash)

• Exemple

  EDITOR=emacs 
  VISUAL=emacs 
  SUNADAHOME=/inf/lang/ada 
  LC_CTYPE=iso_8859_1 
  EXPORT EDITOR VISUAL SUNADAHOME LC_CTYPE
  

.zshrc, .bashrc (en zsh ou bash)

• Spécificité des shells zsh et bash
• Initialisation propre à l'utilisateur
  • situé dans le HOME de l'utilisateur : ~/.zshrc ~/.bashrc
  • redéfinition du prompt PS1
  • définition des aliases
  • définition de fonctions
  • peut-être "ressourcé" . ~/.bashrc ou source ~/.bashrc . ~/.zshrc ou source ~/.zshrc

• Exemple

  alias ls='ls -F' 
  alias ll='ls -laF' 
  alias a='alias' 
  alias h='history' 
  alias j='jobs -l' 
  unalias=rm
  

.login, .cshrc, .tcshrc, .logout (en csh ou tcsh)

• .login : Fichier d'initialisation d'un login C-shell
  • interprété à chaque login
  • définition de nouvelles variables
  • peut-être "ressourcé" par source .login
• .cshrc/.tcshrc : Fichier d'initialisation d'un Csh
  • réinterprété à chaque invocation du csh/tcsh
  • définition des aliases (shells interactifs)
  • peut-être "ressourcé" par source .cshrc/.tcshrc
• .logout : Fichier de clôture d'une session C-shell
  • effacement des fichiers temporaires, clear écran

• Exemple

  setenv	EDITOR	emacs 
  setenv	VISUAL	emacs 
  setenv	SUNADAHOME	/inf/lang/ada 
  setenv	LC_CTYPE=iso_8859_1
  

Fonctionnalités spécifiques ENST

• Shell initial par défaut : /bin/sh
  • interprète~/.profile chez l'utilisateur
  • ~/.profile ressource /usr/local/startup/profile
  • .profile déroule /usr/local/startup/shenv qui initialise les variables d'environnement par défaut
  • .profile déroule ~./.shenv qui initialise les variables d'environnement privées de l'utilisateur
• Shell de travail choisi (défaut ou préférence)
• .profile détermine un shell de travail (par défaut: zsh), sinon prend le 1er de la variable SHELLPREF dans le fichier ~/.shenv.preload
• Détermination du système de multifenêtrage
  • .profile lance automatiquement(ou non) le système de multifenêtrage par défaut ou choisi avec les variables WINDOWSYSTEM et WINDOWMANAGER de ~/.shenv.preload

Schéma de fonctionnement

Personalisation de l'environnement

• Procédure d'installation : install-startup
  • menus proposés
  • lire la FAQ (Frequently Asked Questions)
  • choisir l'installation par défaut
  • vérifier le contenu du fichier ~/.shenv.preload
• Fichiers modèles
  • .profile:/usr/local/startup/profile
  • .shenv: /usr/local/startup/shenv
  • .zshrc: /usr/local/startup/zshrc
  • .bashrc: /usr/local/startup/bashrc
• Modification des fichiers d'environnement
  • éditer et compléter le fichier ~/.shenv
  • selon le shell choisi, supprimer ~/.zshrc ou ~/.bashrc, recopier leur modèle /usr/local/startup/{zshrc,bashrc} dans ~/.{zshrc,bashrc} dans le but de les modifier

Patrice Eon © Copyright 2000 Tous droits réservés - optimisé en 1024X728 - 65000 couleurs