Cours IDRIS : Unix_u

Cours du DEA d'Analyse Numérique: Unix

Ce cours dispensé lors de la remise en forme des étudiants du DEA d'Analyse Numérique a été construit en 2 étapes:
-1. Le cours d'Unix de Jean-Philippe PROUX à l'IDRIS a servi de base.(Voir plus haut)
-2. Ce cours a été modifié par Alain PERRONNET pour être adapté à l'utilisation des PC de l' Ecole Doctorale de Sciences Mathématiques de Paris Centre

Début Chap-1

Table des matières du cours UNIX

1. Table des matières du cours UNIX
2. Introduction à Unix
   1. Quelques bonnes raisons pour se mettre à Unix
   2. Description et caractéristiques d'Unix
3. La connexion en local où à distance
4. Le démarrage, un mystère?
5. Où trouver l'information?
6. Tout faire avec et grâce aux fichiers
   1. ls
   2. cp
   3. mv
   4. rm
   5. cd
   6. mkdir
   7. Les droits d' accès aux fichiers et répertoires
      1. chmod
      2. umask
      3. chgrp
      4. chown
      5. Les commandes des ACL
7. A la recherche des fichiers des principaux répertoires
   1. find
   2. La variable d'environnement PATH
   3. type | whereis
   4. diff
8. Comment communiquer son travail à quelqu'un d'autre?
   1. tar
   2. gzip et gunzip, compress et uncompress
   3. ftp
   4. Les Rcommandes
9. Des éditeurs de textes et le contrôle de la ligne de commande
   1. vi | emacs | xemacs | nedit
   2. ed /sed
10. Les redirections: gestion des flux et des processus
    1. Les fonctions et connecteurs
    2. xargs | sh
    3. grep
    4. tail
    5. Exécution d'un processus en avant ou arrière plan
       1. CTRL z | bg | fg
       2. ps | kill
       3. nohup
       4. at
       5. crontab
       6. top
11. L'élaboration de scripts
    1. make
       1. cc
    2. Quelques commandes Unix pour écrire des scripts
       1. sort
       2. uniq
       3. paste
       4. cut
       5. tr
    3. bash
       1. les règles
       2. l'appel de la commande
       3. la désignation des paramètres
       4. les variables locales
       5. les variables d'environnement
       6. les structures de contrôle
       7. ;
       8. for
       9. while | until
       10. break | continue
       11. case
       12. if
       13. set
       14. basename
       15. read
       16. expr
       17. exit
       18. shift
       19. time
       20. wait
       21. size
       22. % | # | %% | ##
       23. (( ))
       24. $( )
       25. eval
       26. set
       27. fonction
    4. awk
    5. perl
    6. cpp
12. Travailler sous X
    1. traceroute
    2. ping
13. Un peu de sécurité
    1. passwd
    2. s[cp|login|sh]
14. Divers
    1. Voir des choses cachées strings | od | ar -tv | nm
    2. Ou le contraire, ne pas les voir
    3. Commandes inclassables ou plutôt système
       1. dd
       2. df
       3. du
       4. mount
       5. split
       6. uuencode / uudecode
    4. Quelques références bibliographiques

2. Introduction à Unix

2.1. Quelques bonnes raisons pour se mettre à Unix

1. Alternative à Windows:
   En dehors des systèmes Windows je suis perdu ! Toutes les machines, du super-calculateur au PC en passant par les stations de travail, sont sous un système d'exploitation de la famille Unix. Il est donc indispensable, si je veux utiliser convenablement l'environnement des machines mises à ma disposition, d'en connaître un minimum !
2. Unix système universel:
   Dans mon entreprise, mon laboratoire, mon université, mon école, les stations de travail ou de calcul (HP, Sun, IBM, Compaq, SGI, etc.) sont sous Unix et le nombre de PC sous Linux est croissant. En sachant utiliser Unix, je peux travailler de manière identique et efficace sur toutes les plates-formes non Windows.
3. Unix système stable:
   Certaines utilisations nécessitent des contraintes de production fortes telles que :
   • la disponibilité (pas de reboot, pas d'arrêt),
   • la performance en charge (nombre d'utilisateurs, de processus),
   • la pérennité (car Unix est basé sur des standards),
   • et la stabilité (pas ou peu de bogue système).
4. Interfaces d'Unix frustres (mais efficaces) ou riches
   Une des principales difficultés d'Unix reste son abord par ligne de commande, un peu démodé demandant un minimum d'investissement avant de pouvoir faire la moindre tâche. Ce type d'interface frustre reste pourtant inégalé en efficacité depuis 30 ans ! Par ailleurs, il existe depuis plus de dix ans des interfaces graphiques comparables à ceux du système Windows et maintenant les environnements graphiques sous Linux, par exemple KDE, qui n'ont plus rien à envier à celui des systèmes Microsoft.
5. Devenez votre propre ingénieur-systême
   Sur un système d'exploitation, on ignore en général souvent ce qui se passe "derrière" chacune des actions effectuées. Si ça marche, tout va bien. Pourquoi chercher plus ? Cette ignorance peut être sans conséquence sur le travail quotidien jusqu'au jour où l'ingénieur système change une brique du système (via un service pack ou une mise à jour), modifie un logiciel, ajoute une fonctionnalité ; jusqu'au jour où un disque dur de votre station se "crashe" et que vous devez en quelques heures changer d'ordinateur et/ou de compte et surtout continuer à travailler.
6. Ecriture de scripts de commandes
   Autre exemple, vous avez l'habitude de rajouter/supprimer quelque chose à la main dans un ou deux fichiers chaque jour, aucun problème ! Comment faire si, pour une raison ou une autre, vous avez 500 fichiers à traiter et que la situation soit urgente (fin de thèse, papier/rapport à renvoyer rapidement etc.) ? Ecrivez un script de commandes Unix!
7. Unix répond à vos besoins
   Unix est un des rares systèmes permettant de résoudre l'ensemble des problèmes cités plus haut. Vous avez la possibilité d'installer, de tester, d'utiliser sur de multiples plateformes un système pérenne, ouvert et sans réelle limitation.

Retour début

2.2. Description et caractéristiques d'Unix

• Système ouvert (pas de code propriétaire ; seules certaines implémentations sont propriétaires).
• Multitâches (plusieurs programmes peuvent s'exécuter en même temps, sans blocage).
• Mémoire protégée (pas d'interaction entre les programmes) et virtuelle (le système peut utiliser plus de mémoire que la mémoire physique disponible).
• Multi-utilisateurs (plusieurs utilisateurs travaillent sur la même machine en même temps), gestion des droits.
• Interactif et batch.
• Interface graphique X et shell (interpréteur de commandes).
• Plusieurs centaines d'outils (manipulation de texte, développement de logiciels, communication etc.).

Sur un système unix, on trouve deux types de personnes, celles qui vont utiliser le système (user utilisateur) et celles qui vont l'administrer (root administrateur). Les premières ont le droit d'exécuter certaines commandes propres à leur environnement et leur travail, quelques commandes liées au système leur sont interdites. Seuls les administrateurs peuvent installer et configurer. Ils sont chargés de la bonne marche de la machine.

Retour début

3. La connexion en local ou à distance

Dans le cadre du DEA, vous devez:
- être inscrit au DEA d'Analyse Numérique;
- aller au bureau de Mme Luce Loriller (bureau 1B3) pour:

• retirer les chartes, puis les lire et enfin les signer;
• rapporter ces chartes signées pour obtenir le login et password;
• donner une caution pour obtenir une clef électronique des salles informatiques (caution récupérée lors du retour de la clef).

En fait, avec l'obtention du login/password, vous obtenez réellement:

• un login (uid),
• un mot de passe associé (????),
• un groupe (gid),
• un répertoire de travail (HOME),
• un langage de commandes (shell).

Dès lors que vous êtes devant un PC de l'une des salles informatiques, c'est à dire en " connexion locale", vous pouvez saisir votre login puis votre password sur l'écran, dans les 2 cases titrées. Attention Unix fait la différence entre majuscule et minuscule.

Un environnement graphique (KDE) s'ouvre avec une gestion de la souris et des fenêtres suffisamment explicites pour démarrer. Notamment, en bas de l'écran, vous trouverez le bouton K qu'il suffit de pointer avec la souris, bouton gauche enfoncé et non relaché, pour obtenir un menu ascendant, le parcourir pour obtenir un sous-menu, ... et relacher le bouton gauche de la souris pour demander l'exécution de l'option sur-lignée.

Pour la connexion à distance, vous avez bien sûr besoin d'être déjà sur un ordinateur unix/windows, un terminal X ou un simple minitel et d'établir un lien vers la machine Unix cible. Chaque type de connexion dépend de la plateforme d'origine. Prenons deux exemples :

• soit vous souhaitez juste avoir une fenêtre texte, pas trop de problème : il suffit d'utiliser la commande telnet ou ssh (disponible sous les deux environnements, windows ou unix) qui vous invitera à rentrer votre login/mot de passe,
• soit vous voulez avoir du multi fenêtrage :
  - sous Unix pas de soucis un telnet ou ssh avec un export de l'affichage suffit.
  - sous Windows, c'est plus dur puisqu'il vous faudra acheter un émulateur X (idem sous Mac). C'est la même chose si vous voulez avoir un environnement Windows sous Unix !

Remarque : pour sortir d'une session, il est impératif d'utiliser les procédures de déconnexion, en effet unix (comme d'autres systèmes) a besoin de sauvegarder certaines données (flush des buffers via la fermeture des fichiers), démontage des disques pour forcer une mise à jour des fichiers systèmes, etc. Aussi si vous éteignez une machine Unix, vous risquez d'endommager les fichiers sur les disques. Vous devez faire un exit pour revenir à la fenêtre primaire, puis éventuellement un halt pour arrêter le système (si vous êtes autorisé à le faire).

Retour début

Le démarrage, un mystère ?

Donc, vous voilà connecté à une machine Unix sous X (en fait X11-windows). Que s'est-il passé au démarrage de votre session ?

1. Sachez d'abord que vous êtes sous votre répertoire HOME. C'est un espace disque qui vous appartient, à vous et à vous seul (voir "droits" plus loin). Normalement vous pouvez écrire et lire tous les fichiers qui s'y trouvent. Vous êtes responsable de tout ce qui s'y passe (piratage, saturation des espaces disques, etc...). En général, cet espace est accessible par le chemin suivant /share/thot/users/groupe/login1 (dans le cas où de multiples groupes existent sur la machine et que login1 soit votre login). Le caractère ~  remplace avantageusement cette chaîne. Il permet également de référencer un sous-répertoire de HOME quelconque ~/rep    par exemple et donc d'éviter de taper le chemin complet (/share/thot/users/groupe/login1/rep).

Remarque : si vous êtes login1, ~   et ~login1   sont identiques.

Si vous êtes perdus, pour connaître le répertoire courant, utilisez la commande pwd, et si vous voulez savoir qui vous êtes, utilisez la commande id.

2. Le choix d'un shell peut conditionner une grande partie de votre travail. Le shell est simplement un interprèteur de vos commandes. Il va également déterminer les fichiers responsables de la mise en place de votre environnement et gérer la mémoire. Il se nomme ainsi (coquille) car il enveloppe le noyau Unix, toutes les commandes sont passées au noyau à travers votre shell).

Pour le choix d'un shell, deux grandes familles s'affrontent : les shell-iens et les cshell-iens : la guerre dure depuis longtemps mais est en passe d'être gagnée par les premiers ! Comme vous êtes débutant, je vous conseille de vous rallier au futur vainqueur, c'est-à-dire les shell de la famille du sh (sh, ksh, bash, zsh), l'autre famille csh étant uniquement représentée par le tcsh et le csh lui-même.

Sur votre station ou votre PC sous Linux vous avez certainement le choix entre le bash, le ksh, le tcsh et le zsh. Je conseille donc naturellement le shell bash qui a été écrit pour Linux et possède un grand nombre de fonctionnalités communes. Nous allons maintenant baser la suite du cours entièrement sur le bash (les différences entre ces shells sont extrêmement minimes).

Les conséquences d'un tel choix ne sont pas anodines. En effet, votre séquence de "boot" (connexion) est contrôlée par 1 ou 2 fichiers de démarrage. Un premier fichier est exécuté (avant que vous n'ayez la main) c'est le .bash_profile. Ce fichier se trouve dans votre HOME et est précédé par un point (lui permettant de rester "caché" si l'on utilise un simple ls). Ce fichier sert essentiellement à positionner, par défaut, toutes les variables d'environnement utiles au bon fonctionnement de votre session de travail comme le positionnement des chemins (path) par défaut. Il sert également à définir (via la variable ENV généralement valorisée par ENV=.bashrc) le nom du fichier qui sera exécuté juste après le .bash_profile et qui sera lancé à par chaque appel à /bin/bash déclenché pour ouvrir une nouvelle fenêtre, ou un sous-shell ou ou dans un script (uniquement si cette variable a été exportée voir la suite du cours).

Le fichier .bashrc permet de rajouter des fonctionnalités telles que la définition d'alias (que l'on utilisera plus loin) ou de fonctions.

A noter que, quel que soit le shell utilisé, tous les environnements sont initialisés par le fichier /etc/profile modifiable uniquement par l'administrateur.

Le nom des fichiers .bash_profile et du .bashrc peuvent changer suivant les shells et leurs implémentations. Pour ksh sur Unix, les fichiers se nomment .profile et .kshrc. Dans tous les cas, voir le man de votre shell !

Retour début

Où trouver de l'information sur Unix?

Comment exécuter une commande nommée ici cmd ?

cmd [[login@]machine] [-a] fic[.ps|.gif]

Comment interpréter les symboles ci-dessus?

• Les [ ] indiquent un argument facultatif. Par exemple un login ou une machine par défaut.
• a | b indique un choix entre a et b .

• cmd fic
• cmd -a fic
• cmd machine fic
• cmd machine -a fic
• cmd login@machine fic
• cmd login@machine -a fic       et fic pouvant devenir fic.ps ou fic.gif

En général une commande Unix admet une syntaxe composée de :

• -option : option booléenne; par exemple: ls -l
• -option[=]valeur : option avec valeur; par exemple: split -b 10k
• fichier : chemin d'accès à un fichier; par exemple: ls fic
• ou les deux ou trois à la fois; par exemple: ls -rtl fic

Évitez de faire "autrement" en cas de difficulté. Ne pas comprendre quelque chose n'est pas grave, ne pas chercher à comprendre l'est plus. Bien sûr disposer de 10 minutes à chaque difficulté n'est pas simple. Un seul grain de sable peut gripper toute la mécanique des systèmes d'exploitation et avoir des conséquences fâcheuses sur vos fichiers ou programmes et donc sur votre travail.

Dans la suite du cours, seules les commandes indispensables accompagnées des options les plus utiles, seront présentées. Si vous souhaitez la liste exhaustive des options de chaque commande, n'hésitez pas à consulter le man après avoir listé les commandes des répertoires /bin et /usr/bin et /usr/sbin.

Retour début

Tout faire avec et grâce aux fichiers

• il peut représenter tout d'abord des données ou un programme;
• il peut aussi représenter un répertoire (d) ! (c'est un fichier rempli d'index);
• il peut être également un lien symbolique (l), c'est à dire pointer sur un autre fichier (même plus haut dans l'arborescence, cycle possible);
• il peut posséder un statut particulier (device) lorsqu'il permet d'accéder à un périphérique (disque, carte son etc.).

Remarques sur le nom des fichiers:

• un nom de fichier qui commence par un / est dit nom absolu, il est nommé en partant de la racine et en descendant dans les répertoires suivants.
• un fichier qui ne commence pas par un / est dit nom relatif, il est recherché à partir du répertoire courant.
• il n'y a pas de limitation sur le nom des fichiers (à part les caractères spéciaux / ([%#$...) qu'il est préférable d'éviter!)

Tous les fichiers, quels que soient leurs types, sont sur des systèmes de fichiers (file system). Attention, chaque système (operating system) a son propre file system et donc son propre formatage (surtout les disquettes !)

• Dos : FAT16,
• Windows9X : FAT 16, FAT 32,
• NT : NTFS,
• Mac : HFS,
• Linux : ext2, ext3 ( et tous les autres : journalisé, parallèle, raid etc.).

Les principales commandes d'Unix:

ls

Si vous trouvez que c'est trop long, le Korn shell offre la possibilité de créer des alias. Voilà un alias de la commande ls -rtl qui peut ainsi être appelée par ll en procédant ainsi :
alias ll='ls -rtl'
Cette commande peut être ajoutée dans votre fichier .bash_profile.

Pour connaître la liste des alias faites simplement alias .

Ma_machine>ll

-rw-r--r--   1 jpp user  1372160 dec 14 14:05 htmldoc-1.6-source.tar
drwxr-xr-x   3 jpp user     1024 dec 14 14:19 htmldoc-1.6
drwxr-xr-x   6 jpp user     1024 dec 22 13:26 lirc
drwx------   5 jpp user     1024 dec 28 11:37 Desktop
drwxr-xr-x   5 jpp user     1024 dec 28 17:06 john-1.6
drwxr-xr-x   2 jpp user     1024 jan 11 16:17 bin
-rw-r--r--   1 jpp user    25861 jan 12 13:04 ref.html
-rw-r--r--   1 jpp user    70144 jan 14 12:22 poster.tar
drwxr-xr-x   2 jpp user     1024 jan 14 12:46 poster
-rw-r--r--   1 jpp user   575186 jan 15 09:46 vitrail12.tiff
-rw-r--r--   1 jpp user   815042 fev  4 17:16 pcmcia-cs-3.0.8.tar.gz
-rw-r--r--   1 jpp user      620 fev  5 13:52 Xrootenv.0
-rw-r--r--   1 jpp user   114525 fev  9 09:23 lirc-0.5.4pre8.tar.gz
-rw-r--r--   1 jpp user   624640 fev 12 10:57 nets-2.0.tar
drwxr-xr-x   3 jpp user     1024 fev 12 10:59 usr
-rw-r--r--   1 jpp user 13953173 fev 16 08:28 imp3.ps
-rw-r--r--   1 jpp user     6774 fev 16 16:25 sondage.html
Ma_machine>

Il n'est pas possible de passer des options/variables à un alias. Il faut utiliser une fonction c'est à dire une commande.

Retour début

cp

Ma_machine>cp fic1 fic2
Ma_machine>cp fic1 rep
Ma_machine>cp -R rep1 rep2

Retour début

mv

Ma_machine>mv fic1 fic2  #(fic1 n'existe plus)
Ma_machine>mv fic1 rep  #(fic1 existe, mais sous rep)

Retour début

rm

Ma_machine>rm -f fic*
Ma_machine>rm -r rep
Ma_machine>rm -rf rep

Retour début

cd

Ma_machine>cd bin
Ma_machine>cd bin/new
Ma_machine>cd .././src

La variable d'environnement $HOME permet de définir de manière générique son répertoire personnel.

Remarque: Taper cd $HOME <=> cd ~   <=> cd

A noter deux répertoires spéciaux, le répertoire courant (c'est-à-dire dans lequel vous êtes) représenté par le point ., et le répertoire père représenté par le double point ..

cd . ne sert donc à rien !

cd - permet de sauter d'un répertoire à l'autre. Vous êtes sous rep1, faites cd rep2, vous êtes maintenant sous rep2. Faites cd - et vous vous retrouverez sous rep1. Maintenant remplacez rep1 et rep2 par des noms de répertoire très longs et différents, vous comprendrez tout l'intérêt de cd -.

cd peut avoir des comportements étonnants pour celui qui ne connaît pas son environnement. Vous êtes habitué à faire cd rep, avec rep un des répertoires de ., mais un cd rep_ailleurs avec rep_ailleurs un répertoire ne se trouvant pas sous . mais sous lieu_du_rep_ailleurs, c'est plus étonnant!
En fait, c'est possible grâce à la variable d'environnement CDPATH, qu'il suffit de positionner par la frappe de export CDPATH=:.:..:lieu_du_rep_ailleurs dans votre .bash_profile.
Remarque : la liste des répertoires à inclure dans la recherche sont séparés par le caractère :

export PS1="$(echo 'machine:$PWD>')"
le prompt Unix sera égal par exemple à :
machine:/usr/local/bin/>

ou

export PS1=$(echo '${PWD##*/}"/> "')
le prompt Unix sera égal alors à :
bin/>

ou encore avec le nom retrouvé de la machine
export PS1='$(hostname):${PWD#} -bash-> '
corse.edcsm.jussieu.fr:/share/thot/users/dea-ana/martin-bash-> Magique? Pour mieux comprendre les $( ' $PWD ##*/ "' lire la suite du cours

Retour début

mkdir

Ma_machine>mkdir projet1
Ma_machine>mkdir -p projet2/src/new

Retour début

Les droits d' accès aux fichiers et répertoires

Les fichiers peuvent être en mode écriture (w), en mode lecture (r) ou les deux (rw), pour vous, pour les membres de votre groupe ou pour les autres (c'est-à-dire pour le reste du monde).

Lorsque vous utilisez l'alias créé plus haut (ll), vous obtenez en début de chaque ligne "drwxr-sr-x" ou "-rw-r--r--" par exemple.

Le 1^er caractère vous indique s'il s'agit d'un fichier (-) ou un répertoire (d), les trois triplets suivant concernent respectivement le propriétaire du fichier, le groupe du propriétaire, et enfin tous les autres de manière exclusive. Chaque triplet se compose d'un r pour le 1^er caractère, d'un w pour le 2^e et d'un x pour le 3^e, un - exprime la négation. Nous avons déjà expliqué les deux premiers caractères r et w, x précise que le fichier peut être exécuté s'il s'agit d'un fichier, ou qu'il peut être "traversé" s'il s'agit d'un répertoire.

Donc si un jour, le shell vous injurie
bash: mon_code: 0403-006 Execute permission denied.
Les droits d'exécution de votre exécutable ne sont probablement pas bons (-) au lieu de (x).

Les problèmes peuvent se cumuler. Par exemple, si vous essayez de copier un fichier dans un sous-répertoire (cp fic1 rep2/rep3/fic1), il faut que vous puissiez :

1. lire le fichier fic1 (ce n'est pas forcément évident si le fichier n'est pas le vôtre), droit en lecture sur le fichier
2. traverser le sous-répertoire rep2 (et tous les autres au-dessus !), rep2 et rep3 en x au moins pour vous,
3. écrire dans rep3 (sous rep2/rep3, vérifier les droits de .)

Retour début

chmod

Chaque triplet se code par l'addition de 4, 2, 1, ou 0. Pour un rwx il faudra ajouter 4+2+1=7, pour r-x 4+0+1=5 etc. Donc les combinaisons vont de 0 (- aucun droit) à 7 (rwx tous les droits). Cela s'applique à chaque groupe triplet (propriétaire, groupe et autres).

La commande chmod permettant de positionner rwxr-x--- sur fic1 à la syntaxe suivante :

Il existe aussi un autre moyen de positionner les droits d'un fichier avec cette même commande. Vous pouvez utiliser des +, - ou = pour ajouter, supprimer ou fixer des droits à l'une ou l'autre des catégories u (user), g (group), o (other) ou a tous (a) en précisant le type de droit d'accès, r (read), w (write) ou x (execute).

 
chmod g+w fic1
chmod o-x rep
chmod u+rx,g-w fic2
chmod u=rwx,g=rx,o=- fic
chmod -R a+r fic
 

Si le changement de droits s'applique à un répertoire, vous pouvez changer tous les droits des fichiers et répertoires inclus dans ce répertoire via l'option -R.

Retour début

umask

Bien évidemment, il existe dans tous les gestionnaires de fenètres (Window-managers) modernes (CDE, KDE etc.) des commandes graphiques employant la souris (saisie + glisse du fichier ou sous-menu obtenu par le bouton droit, ... ) permettant d'éxecuter ces commandes (chmod, mv, cp etc.) mais leur mode d'emploi reste dans tous les cas NON standard.

Retour début

chgrp

Retour début

chown

Retour début

Les commandes des ACL

En effet, jusqu'à maintenant nous n'étions pas capables d'autoriser une personne particulière (différente du propriétaire du fichier) à avoir des droits en lecture, écriture etc. sans que toutes les personnes de son groupe aient ces mêmes droits.

Si vous développez un projet avec une autre personne, vous ne souhaitez pas forcément que tout le laboratoire puisse jeter un oeil à votre travail, confidentialité oblige. Les ACL vont rajouter un niveau de permission plus précis sur les droits unix.
Pour faire simple il suffit de protéger le répertoire du projet et laisser les permissions unix classiques sur les fichiers contenus dans le répertoire.

Ma_machine$>mkdir projet_proteger_acl
Ma_machine$>setfacl -m  user:login_de_mon_copain:7,m:7 projet_proteger_acl

Pour vérifier la bonne affectation de ces nouveaux droits, utilisez getfacl dès que vous voyez un + dans le ls.

Ma_machine$>ls -lda testacl
drwx------+  2 jpp      staff        512 Mar 12 17:22 testacl


Ma_machine$>getfacl projet_proteger_acl
# file: projet_proteger_acl
# owner: jpp
# group: staff
user::rwx
user:login_de_mon_copain:rwx   #effective:rwx
group::---                     #effective:---
mask:rwx
other:---

Pour supprimer un droit ACL, seule la commande setfacl -d user:login peut être utilisée.

Le traitement qui a été effectué sur user peut également être fait sur group. Pour plus d'informations, taper man setfacl.

Retour début

A la recherche des fichiers des principaux répertoires

Si vous installez un produit chez vous sur votre Home, vous pouvez vous aussi créer un ~/bin, ~/lib et ~/include.

Retour début

find

Voilà des exemples qui résument les possibilités de find ( find  "à partir de" "que faire" "que faire" etc.) :

• cet exemple va chercher tous les noms des fichiers qui comportent la chaîne de caractères exe1 dans les noms des fichiers du répertoire rep1 ainsi que dans tous ses sous-répertoires. Attention, la recherche est récursive.
  

  ---

  
  Ma_machine>find rep1 -name "*exe1*" -print
  /share/thot/users/rep1/exe1
  /share/thot/users/rep1/pexe11
  /share/thot/users/rep1/llexe12
  Ma_machine>
  
  

  ---

• Si vous cherchez un include particulier (au dessous signal.h ) sans avoir la moindre idée de sa localisation, partez de la racine / :
  find / -name "signal.h" -print
  Attention, cela risque de prendre un peu de temps surtout si vous avez des disques de plusieurs giga octets ! De plus si vous n'êtes pas root, un grand nombre de messages vont apparaître indiquant l'impossibilité de traverser certains répertoires.

• Si vous voulez tous les fichiers core égarés sur votre disque et qui consomment de la place inutilement :
  find ~ -name "core" -print

• Encore plus fort, si vous voulez supprimer directement les fichiers trouvés, il est possible plutôt que de faire afficher seulement les noms de ces fichiers, de les détruire également :
  find ~ -name "core" -exec rm {}  \;
  Remarque : {} permet de passer les noms des fichiers trouvés par find à la commande rm et le \; à la fin est obligatoire.
• Avec deux filtres c'est possible !
  find ~ \( -name "*.L" -o -name "*.o" \) -exec rm {}  \;
      équivalent à
find ~ -name "*.[Lo]" -exec rm {}  \;
• En fait tout est possible, les filtres sont évalués de gauche à droite. Ici on essaye de supprimer les fichiers contenant "chaine" ; si on n'arrive pas à faire le rm, on affiche le fichier
  find . -exec grep -q chaine {} \; ! -exec rm {} \; -print
• Il est possible de spécifier dans le filtre le type d'élément cherché (fichier -type f, ou répertoire -type d) ou ayant une taille particulière (-size nk), le -ok a le même rôle que -exec avec la confirmation en plus.
  find . -type -d -print
  find . -size 0k -ok rm {} \;

• Il est également possible de spécifier la date de l'élément cherché (-atime +n avec n le nombre de jours depuis le dernier accès)
  find / \(-name "a.out" -atime +7\) -o \(-name "*.o" -atime +30\) -exec rm {} \;

• Un autre cas pratique, vous n'arrivez pas à faire un rm sur un fichier car son nom contient un caractère "bizarre". Nous allons demander à find de détruire (avec confirmation via un -ok ) un fichier par son numéro d'inode.
  ls -i (pour trouver son numéro d'inode ici 733)
  find . -inum 733 -ok rm {} \;
  • Remarque sur le rm : si vous voulez supprimer un fichier qui commence par
    • - , vous allez avoir quelques surprises, alors utilisez l'option -- de rm ainsi :
      rm -- fic_avec_un-
    • # , faites rm ./#fic_avec_un# ou rm \#fic_avec_un#

Retour début

PATH

Ainsi votre exécutable exe1 pourra être exécuté de n'importe où en tapant "exe1". Attention à ne jamais écraser le PATH initial car il contient déjà l'essentiel des répertoires utiles (si vous l'écrasez, il n'y aura plus grand chose qui marchera !).

Maintenant vous êtes en mesure de comprendre pourquoi une commande présente dans votre répertoire courant ne s'exécutait que par ./ma_commande et non simplement par ma_commande, le . (c'est-à-dire le répertoire courant) n'était pas dans votre PATH ! Le shell était alors incapable de la trouver, même si elle se trouvait sous "ses" yeux !

Attention à l'ordre car c'est le premier exécutable trouvé qui sera exécuté.
Faites toujours plutôt PATH=$PATH:. que PATH=.:$PATH, car dans ce deuxième cas une commande peut avoir une signification différente suivant le répertoire où elle est exécutée.

Retour début

type ou whereis

Ma_machine>type chgrp
chgrp is /usr/bin/chgrp
Ma_machine>whereis chgrp
chgrp: /bin/chgrp /usr/man/man1/chgrp.1
Ma_machine> whereis whereis
whereis: /usr/bin/whereis /usr/share/man/man1/whereis.1.gz

Cas réel : j'ai copié et modifié un script chgrp qui se trouve directement dans mon HOME et les modifications semblaient ne pas être prises en compte bien que je la lance depuis mon HOME !

Puisque type me donne /usr/bin/chgrp, cela veut dire que si j'exécute chgrp, le script exécuté sera celui sous /usr/bin, et non celui du HOME ! Pourquoi? Une seule explication : /usr/bin est placé avant le "." dans la variable d'environnement PATH.

Retour début

diff

Dans cet exemple qu'est-ce qui diffère entre mes deux scripts chgrp ?

Ma_machine>diff ~/chgrp ~/bin/chgrp 
>if (( $? ==0)) 
> then 
> rm poub tempo 
>fi

Les < (respectivement les > ) indiquent que seuls ces éléments se trouvent dans le premier (respectivement dans le deuxième) fichier.

Remarque : diff a une option -r lui permettant d'explorer des répertoires et d'en déterminer les différences, en comparant tous les fichiers deux à deux dans tous les sous-répertoires.

Retour début

Comment sauvegarder, transporter ou communiquer son travail à quelqu'un d'autre ?

Retour début

tar

Pour détarer le c (create) devient x (extract) ainsi :
tar -xvf mon_boulot.tar
l'arborescence de rep1 sera complètement reconstituée sous le répertoire courant.

Si vous souhaitez connaître le contenu du tar sans le "détarer", utilisez l'option t ainsi :
tar -tvf mon_boulot.tar
Cette option est très utile ...

• Imaginez que vous "détariez" sur votre Home un fichier tar contenant 200 fichiers . Sans arborescence, ces 200 fichiers iraient se mêler à vos fichiers du Home, bon courage pour le nettoyage si vous souhaitez supprimer tous les fichiers!
• Plus grave, si un fichier issu du tar a le même nom qu'un fichier déjà existant sur votre répertoire Home ... votre fichier sera remplacé !

Remarque : si vous souhaitez rajouter un fichier supplémentaire à votre fichier tar, vous pouvez le faire grâce à l'option -r ainsi tar -rvf mon_boulot.tar fichier_suppl

Ceci dit, si votre code tient dans un seul fichier, rien ne vous empêche de l'envoyer par mail puisqu'il est en format ASCII, par la simple commande Unix :
mail mon_copain@autre_labo.fr < super_commande_perso (l'utilisation de < sera vue plus loin)

Attention, si vous utilisez la possibilité "d'attacher" un document via votre mailer favori, assurez vous que :

1. votre mailer soit bien configuré, (envoyez-vous un mail avec "attachement" pour vérifier)
2. votre destinataire dispose d'un mailer acceptant un attachement ! (c.-à-d. qu'il soit de type MIME, c'est le cas avec netscape, exmh, mutt, IE etc.)

Faites aussi attention à l'espace d'arrivée de votre courrier, veillez à bien configurer le .forward . Ce fichier sert à renvoyer vos messages vers une autre machine, cela permet de n'avoir qu'une boîte aux lettres à vérifier. Il doit contenir une ligne de texte de ce type
autre_login@un_autre_labo.ailleur.fr

Retour début

compress et uncompress, gzip et gunzip

Remarque : il est inutile de compresser un fichier déjà compressé ! On ne gagnera rien, pire il sera probablement même plus gros !

Retour début

ftp

• soit connaître son login/passwd (pas recommandé),
• soit avoir votre propre login sur cette machine.

La commande s'utilise ainsi :
ftp autre_machine.autre_domaine.fr
elle vous invite à rentrer le login et le passwd du compte distant,
puis tapez :
put mon_boulot.tar.gz

Le fichier sera alors placé dans le HOME du login distant.
Remarque : si vous avez plusieurs fichiers à transférer, vous pouvez utiliser "mput *.gz". Il est possible de s'affranchir des YES (return) pour chaque transfert en désactivant le prompt via la commande prompt avant le mput ou mget.

Sous ftp, les commandes ls, pwd et cd peuvent être utilisées pour lister et changer de répertoire sur la machine distante, et !ls, !pwd et !cd ou lcd pour faire de même sur la machine locale .

Dans le cas où vous avez laissé le fichier chez vous, et avez simplement dit à votre collègue de venir le prendre via un get sous un ftp, pensez à mettre les droits de lecture sur ce fichier et lui laisser la possibilité de traverser votre HOME.
Reste ensuite au login distant à décompresser (on l'a vu !) et à détarer via :
tar -xvf mon_boulot.tar

Remarque sur le mode binary ou ascii de ftp.
Si vous restez dans le monde Unix( /linux), vous n'avez pas à vous soucier du mode quels que soient les machines utilisées et les fichiers transférés.

Attention, si vous transférez à partir de ou vers un PC sous Windows ! Si c'est un fichier texte, précisez le mode ascii. D'autres environnements comme IRIX préfèrent que vous stipuliez bin ou ascii.

Pour sortir de la commande ftp, tapez quit.

Retour début

Rcommandes

Ces Rcommandes sont rsh, rcp, rlogin...
Toutes ces commandes seraient déjà connues si elles n'avaient pas de r ( login, cp ...). Le r (pour remote) précise que la commande va s'exécuter sur une autre machine.

Pour que ces commandes fonctionnent, il est impératif d'avoir son fichier .rhosts à jour. Ce fichier permet de s'affranchir du mot de passe normalement nécessaire lors d'une connexion sur une autre machine.

Voici un exemple de fichier .rhosts existant sur le HOME de la machine_A pour le compte login_A .

machine_B.mon_labo.fr login_B
eclipse.totale.fr observateur

• rcp [-r] [[loginA@]machineA:]/fichier [loginB@[machineB:]]/fichier : copie d'une machine sur une autre, loginX et machineX peuvent être omis. L'option -r permet de traiter une copie récursive pour recopier les répertoires.

---

rcp -r observateur@eclipse.totale.fr/.netscape .

---

• rsh machineB commande : exécute commande sur la machineB (alors que rsh a été exécutée sur la machine courante, dans l'exemple suivant le fichier liste_des_utilisateurs_distants est créé sur la machine courante !)

---

rsh eclipse.totale.fr who > liste_des_utilisateurs_distants

---

• rlogin machineB [-l login] : établit une connexion sur la machineB (comme la commande telnet mais sur un autre port) sous le login indiqué

---

rlogin machine -l jpp
... connexion direct ...

---

Remarque : il est fortement conseillé de vérifier les droits d'accès et le contenu du fichier .rhosts régulièrement. Supprimer toutes les entrées inutiles, ou les éventuels rajouts de personnes mal intentionnées.

Retour début

Des éditeurs de textes et le contrôle de la ligne de commande

Chacun a ses propres avantages et défauts, le seul conseil serait : "prenez le même que votre collègue de bureau !", il pourra ainsi vous renseigner et vous aider (aucun des deux n'est vraiment simple au début). Pour ma part, je suis convaincu qu'emacs est mieux, mais son côté "usine à gaz" fait que j'utilise toujours vi ! (enfin vim, version améliorée de vi) (et mon collègue de bureau aussi !).

Ceci dit, nedit est également disponible sur la plupart des machines et ne pose aucun problème au débutant (sauf pour le trouver, il est peut être sous /usr/bin/X11/nedit). Il s'utilise comme un traitement de texte et colorie les mots clés, par contre, il n'offre pas toutes les possibilités de emacs ou vi.

vi utilise des fichiers temporaires, et parfois l'espace où il stocke ses fichiers est plein. Pour utiliser un autre espace, positionner ainsi EXINIT, export EXINIT="set dir=autre_file_system".

Je vous conseille quand même vi, car on retrouve les mêmes séquences dans les expressions régulières, les crons, sed, ed etc.

Les principales commandes sous vi.

Commandes	Fonctions
i	basculement en mode insertion
a	basculement en mode ajout
cw	modification du mot courant
esc	sortie du mode d'insertion/ajout/modification
J	concaténation de la ligne courante et de la suivante
x	effacement du caractère suivant
X	effacement du caractère précédent
$	déplacement en fin de ligne
0	déplacement en début de ligne
dd	suppression de ligne et copie dans le buffer
dw	suppression de mot et copie dans le buffer
p	copie du buffer sous la ligne courante
D	effacement jusqu'à la fin de la ligne
.	répétition de la dernière commande
u	annulation de la dernière commande
h	déplacement vers la gauche
l	déplacement vers la droite
j	déplacement vers le bas
k	déplacement vers le haut
CTRL F	déplacement sur la page suivante
CTRL B	déplacement sur la page précédente
:	entrée dans le mode de commande pour les commandes suivantes
w [fic]	sauvegarde dans le/un fichier
q	sortie de vi
q!	sortie sans sauvegarde
x	sortie avec sauvegarde
r fic	insertion de fic dans le fichier courant
! cmd_du_shell	exécution d'une commande shell
%s/chaine1/chaine2/g	substitution dans tout le fichier de chaine1 ou rexp par chaine2 (plusieurs fois par ligne)
sx,y/chaine1/chaine2/	substitution de x à y de chaine1 ou rexp par chaine2
s4,./chaine1/chaine2/g	substitution de la 4e ligne à la ligne courante de chaine1 ou rexp par chaine2 (plusieurs fois par ligne)
s4,$/chaine1/chaine2/gc	substitution de la 4e ligne à la fin de chaine1 ou rexp par chaine2 (plusieurs fois par ligne) avec confirmation (y,n,q)
g/chaine/l	liste des lignes contenant chaine

Il est possible pour certaines commandes d'utiliser un facteur multiplicatif devant comme 7x ou 3dd.

Une bonne gestion et édition des lignes de commande est fondamentale sous Unix mais dépend fortement de votre shell. Il y a quatre choses à savoir faire absolument (car on le fait 200 fois par jour) :
 

Shell	rappel de la dernière commande	rappel d'une commande cmd	déplacement dans la ligne de commande	complétion
ksh (set -o vi)	Esc k, puis n ou N pour naviguer dans l'historique commande suivante/commande précédente	Esc/ suivie d'une sous chaîne, par exemple Esc/totoCR de retrouver toutes les commandes où le toto était présent	puis l ou h pour aller de droite à gauche puis x pour supprimer et a pour ajouter	titiEsc\ ou titiEsc= listera tous les fichiers commençant par titi
ksh (set -o emacs)	Ctrl p Ctrl n	Ctrl r cmd	Ctrl b Ctrl f	EscEsc
ksh (set -o emacs) + config flèche	flèche "haut/bas"	Ctrl r cmd	flèche "droite/gauche"	EscEsc
csh	!!	! debut_cmd
bash (linux)	flèche "haut/bas" ou !! ou Ctrl p Ctrl n	Ctrl r cmd ou ! debut_cmd	flèche "droite/gauche" ou Ctrl b Ctrl f	TAB ou EscEsc

Config flèche : elle n'est possible qu'en mode emacs. Il faut placer les commandes suivantes dans l'un de vos fichiers d'environnement (.bash_profile par exemple) :

alias __A='^P' # pour remonter dans l'historique des commandes (flêche ascendante)
alias __B='^N' # pour descendre dans l'historique des commandes (flêche descendante)
alias __C='^F' # pour se déplacer à droite sur la ligne de commande (flêche droite) 
alias __D='^B' # pour se déplacer à gauche sur la ligne de commande (flêche gauche) 

Pour passer en mode vi ou emacs sous ksh, il faut insérer dans votre .bash_profile cette ligne set -o vi ou set -o emacs

Pour la gestion de l'historique, deux variables d'environnement existent et peuvent être placées dans votre .kshrc. Une pour la taille de l'historique HISTSIZE et une pour nommer l'historique HISTFILE.

HISTSIZE=5000
HISTFILE=~/.sh_history

• * : équivaux à "n'importe quoi" (chaîne, caractère ...) sauf . et /
  ls *.c listera les fichiers ayant comme suffixe un c
• ? : remplace un caractère dans une chaîne
  cat t?t? affichera le contenu de toto, titi, tata et t1t2
• [group]: sélectionne certains caractères
  cat t[ia]t[ia] affichera le contenu de titi et tata, mais pas toto ni t1t2
• [début-fin]: sélectionne un intervalle
  cat [0-9]*[!0-9] affichera le contenu de tous les fichiers ayant un chiffre au début mais sans chiffre à la fin (dû au !).

Attention aux caractères spéciaux, si vous souhaitez qu'ils ne soient pas interprétés comme le $ () [] " (double quote) # (dièse) ' (quote) ` (back quote) \ (back slash): utilisez le \ (back slash) juste avant.

Exemple : echo il ne faut pas confondre / et \ en Unix.

Trois quotes à ne pas confondre :

• si vous voulez que rien ne soit interprété, placez des ' (quotes) de part et d'autre de votre chaîne.
  >echo '$?*_\'
  >$?*_\
• si vous voulez quand même interpréter les dollars, utilisez les " (doubles quotes),
  >echo "$PATH?*_\"
  >/usr/bin?*_\
• si vous voulez exécuter une chaîne, il est nécessaire de la placer entre ` (back quotes).
  >REP=`ls -lrt *.rpm`;echo $REP
  >-rw-r--r-- 1 jpp jpp 134226 nov 21 17:51 libcdf-2.7-1.i386.rpm

Retour début

sed/ed

Quelques exemples :

• substitution des occurrences d'une chaîne (faux) par une autre (vrai) :
  sed 's/faux/vrai/' fic1 > fic2 remplacera la 1^ère occurrence de la chaîne, pour chaque ligne du fichier.
  sed 's/faux/vrai/3' fic1 > fic2 remplacera la 3^e occurrence de la chaîne.
  sed 's/faux/vrai/g' fic1 > fic2 remplacera toutes les occurrences de faux par vrai.
  sed 's/[Ff]aux/vrai/g' fic1 > fic2 remplacera toutes les occurrences de Faux et faux par vrai.
  

• suppression de lignes :
  sed '20,$d' fic1 supprimera les lignes de la 20^e à la dernière.
  sed '/commentaire/d' fic1 supprimera toutes les lignes ayant le mot "commentaire".
  printf '1d\nwq\n' | ed fic1 supprimera la première ligne du fichier fic1.
  printf 'g/^$/d\nwq\n' | ed fic1 supprimera toutes les lignes blanches.
  

Lorsque le code sed est trop long, vous pouvez mettre les commandes dans un fichier et appeler sed ainsi : sed -f fic_commande_sed fic1 > fic2

Retour début

Les redirections: gestion des flux et des processus

On peut voir ces symboles comme une écriture sur un fichier pour le supérieur, une lecture à partir d'un fichier pour l'inférieur, un simple tuyau pour le pipe. Ce tuyau servant à relier deux commandes entre elles, c'est-à-dire, la sortie de l'une devient l'entrée de l'autre.

Nous allons voir les commandes Unix comme un jeu de construction.

Fonctions et Connecteurs

• entrée commande (0)
  

  

  ---

• sortie commande (1)
  

  

  ---

• sortie erreur (2)
  

  

  ---

• commande type
  

  commande unix

  ---

• création d'un fichier contenant le flux de la sortie commande
  

  >fichier

  ---

• connection de deux commandes

  
  

  |

  ---

• contrôle de l'erreur

  
  

  2

  ---

• fusionne l'erreur et la sortie commande

  
  

  2>&1

  ---

• alimente la commande via l'entrée commande
  

  "frappe au clavier"

  ---

• alimente la commande via la lecture d'un fichier

  
  

  <fichier

Deux exemples avec ces symboles

• grep toto * 2> /dev/null | sort > res

grep toto *		|		sort		>res
		2		> /dev/null

• mon_script 2>&1 | mail jpp@labo

mon_script

2>&1

|

mail jpp@labo

Maintenant que vous avez compris le principe voici une série d'exemples :

• Exemple d'écriture sur un fichier avec > :

• Les informations données par date vont être placées dans mon_premier_fichier.
  date > mon_premier_fichier
  Attention, si le fichier existe il sera détruit ! Sauf si vous avez positionné set -o noclobber. Dans ce cas, si vous voulez vraiment l'écraser il vous faudra faire :
  date >! mon_premier_fichier
• Les informations retournées par who vont être ajoutées à mon_premier_fichier.
who >> mon_premier_fichier

$>cat mon_premier_fichier 
Thu Oct 29 15:39:56 MET 1998 
sfuj742  pts/0 Oct 28 08:00 (xt2-fuji.idris.f) 
jpp      pts/5 Oct 29 08:32 (buddy.idris.fr)
lavallee pts/8 Oct 29 08:39 (bebel.idris.fr)
gondet   pts/9 Oct 29 08:48 (glozel.idris.fr)
$>

• Exemple de lecture d'un fichier avec < :
• Si vous souhaitez envoyer mon_premier_fichier par mail à assist@microsoft.fr, il faut que la commande mail lise votre fichier, pour cela nous allons utiliser "<" (la redirection d'entrée) ainsi :
  mail assist@microsoft.fr < mon_premier_fichier
• Si vous avez un script mon_script qui vous pose de multiples questions, vous pouvez l'automatiser grâce au <. Mettez les réponses dans le fichier les_reponses et faites comme suit :
  mon_script < les_reponses
• Avec les deux symboles :
  mon_script < les_reponses > les_sorties
• Avec deux < on envoie à la commande toutes les lignes tapées en entrée, jusqu'à la chaîne fin, méthode du "here document" :
  wc -l << fin
  "collez quelque chose avec la souris"
  fin
• Encore avec deux < on envoie à la commande toutes les lignes tapées en entrée, jusqu'à la chaîne fin mais cette fois-ci dans un fichier :
  cat > fic << fin
  "collez quelque chose avec la souris ou tapez du code ..."
  fin

• Exemple d'utilisation d'un pipe | :

• Voilà une autre solution pour envoyer un mail :
  cat mon_premier_fichier | mail assist@microsoft.fr
• Si l'on cherche à connaître le nombre de fichiers d'un répertoire :
  ls -la | wc -l
• Si une commande est trop bavarde et génère plusieurs écrans, canalisez-la par :
  commande_bavarde | more
• Le pipe sert très souvent à remplacer le fichier input attendu dans la plupart des commandes par un flux de la commande précédente, cat * | sort
  à la place de
  sort *

Attention : le flux redirigé dans un > ou un | ne concerne que la sortie standard, pas l'erreur standard !

• Pour fusionner les deux flux (sortie et erreur), utilisez cette syntaxe : commande 1> poub 2>&1 qui redirigera le flux 2 vers le flux 1 (attention uniquement avec la famille sh).
• Pour rediriger la sortie d'erreur dans un fichier (sans bloquer le flux standard) :
  commande 2>erreur
• Si vous voulez que les sorties ne soient pas affichées ou conservées dans un fichier, il suffit de les envoyer vers /dev/null ainsi :
  script_bavard > /dev/null

• Pour rediriger la sortie d'erreur dans un pipe sans le flux standard :
  (commande 1>/dev/null) 2>&1 | more

Retour début

xargs/sh

• $>xargs -t -n 2 diff  <<fin
  fic1 fic2 fic3
  fic4 fic5 fic6
  fin
  diff fic1 fic2
  diff fic3 fic4
  diff fic5 fic6
  

• $>ls | xargs -t -i{} mv {} {}.old
  mv chap1 chap1.old
  mv chap2 chap2.old
  mv chap3 chap3.old
  
  

• ou dans un cas plus simple avec sh

  $>echo "ls; pwd" | sh
  chap1.old chap2.old chap3.old 
  /home/jpp/rap
  

Retour début

grep

$>grep bash /etc/passwd

teuler:*:505:502:teuler:/home/teuler:/bin/bash

lavallee:*:506:502:lavallee:/home/lavallee:/bin/bash

corde:*:507:502:corde:/home/corde:/bin/bash

• -i pour ne pas tenir compte des majuscules/minuscules,
• -v pour ignorer un mot,
• -n pour avoir les numéros de ligne,
• -E pour les expressions régulières plus compliquées,
• -l pour lister seulement les fichiers contenant la chaîne recherchée,
• -s pour supprimer les messages d'erreurs.

Pour comprendre voici quelques exemples :

• nombre de lignes en commentaire (commençant par !) dans un code Fortran :
  grep "^!" prog.f | wc -l
• recherche de STOP avec le numéro de la ligne dans tous les sources :
  grep -n -i stop *.f*
• liste de tous les fichiers qui n'ont pas "image" ou "son" dans leur nom :
  ls | grep -vE "(image|son)"
• liste des lignes contenant "image" ou "son" dans tous les fichiers du répertoire courant
  grep -E "(image|son)" *
• liste des fichiers contenant JPP dans une arborescence
  find . -name "*" -exec grep JPP {} \;

Liste des caractères spéciaux	Signification pour les expressions régulières de grep,find,awk ou vi (en partie)	Signification pour le shell
.	caractère quelconque	.
$	fin de ligne	idem
^	début de ligne	idem
[]	un des caractères du crochet	idem
-	de ... à ds [x-y]	idem
?	expression régulière précédente optionnelle	caractère quelconque
*	répétition >=0	chaîne quelconque
+	répétition >0 (pas ds vi)	+
|	ou (pas ds vi)	pipe
()	groupement des expressions (pas ds vi)	groupement des commandes

DÉMO/TD Créer un fichier contenant les valeurs de s1_np se trouvant dans tous les fichiers du répertoire TP/TP1, combien y en a t-il ?. Comptez le nombre d'occurrence de tp_np dans les fichiers n'ayant que deux chiffres dans leur suffixe.

Retour début

tail

• Si vous souhaitez 25 lignes ajoutez -n 25 à la commande tail
• Si votre code est en train de s'exécuter vous pouvez suivre l'évolution de vos fichiers d'output ou de log par cette même commande agrémentée d'un -f.
  tail -f output affichera "en direct live" votre fichier. Sans cette commande, vous seriez obligé d'éditer le fichier et de le recharger toutes les 10 secondes !
• Si vous souhaitez faire le contraire, avoir le début du fichier, utilisez head output

Retour début

processus exécuté en avant ou arrière plan

Quelquesoit votre commande ou votre exécutable, c'est en fait un processus Unix qui peut être facilement contrôlé.

CTRL-z /bg /fg

Sur une commande un peu longue comme un find (que l'on a déjà vu) essayez un CTRL z. Cela bloquera le find et vous permettra de retrouver la main sous le shell. Votre processus sera suspendu. Pour le réactiver sans être de nouveau bloqué tapez bg pour background (arrière-plan).

La séquence CTRLz suivie de bg est identique au & souvent utilisé après une commande. L'avantage de CTRLz + bg est qu'il est possible via fg (foreground, avant-plan) de revenir à la situation de départ (c'est-à-dire comme si vous aviez lancé la commande sans & à la fin), un CRTL c (permettant de tuer votre commande) est donc toujours potentiellement actif.

ps /kill

Au fait, pourquoi vouloir tuer une commande ? Plusieurs réponses :

• vous vous êtes trompé (ça arrive),
• la commande ne répond pas assez vite ou ne répond pas du tout !
• le résultat produit est suffisant.

Mais comment faire si un CRTL c ne marche pas et qu'il n'y a pas de menu "close" dans l'application ? Sous d'autres systèmes, pas grand chose, à part tout redémarrer... Sous Unix, il suffit de trois choses :

• avoir une fenêtre pour taper des commandes, ou pouvoir en créer une (sinon allez voir votre administrateur, root (le login qui a tous les droits) a toujours une fenêtre pour les cas d'urgence),
• trouver le numéro de process de votre commande ou application que vous souhaitez tuer. Pour cela (et en général seulement pour ça) faites un "ps -edf | grep mon_login" ou "ps aux | grep mon_login" suivant votre machine,
• faire un kill numéro_du_process_à_tuer.
  Si ça ne suffit pas, utiliser l'artillerie lourde kill -9 numéro_du_process_à_tuer. (Remarque, un kill -1 permet de relancer un process avec prise en compte du fichier de configuration pour un démon par exemple.)

Ma_machine>ps -edf | grep jpp     
     UID    PID   PPID   C    STIME    TTY  TIME CMD
     jpp  16034  57976   0 08:49:52  pts/6  0:00 -ksh 
     jpp  18032  83270   0 08:57:38      -  4:35 netscape_aix4 
     jpp  24616  84396   4 10:12:30  pts/7  0:00 grep jpp 
     jpp  28788  69868   0 08:49:46      -  0:07 xautolock
     jpp  36206  69868   0 08:49:46      -  0:00 xterm 
     jpp  41836  69868   5 08:49:46      -  0:00 xterm 
     jpp  44662  69868   0 08:49:46      -  0:00 xbiff 
     jpp  52346      1   0 08:49:47      -  0:07 plan 
     jpp  58662  84396  21 10:12:30  pts/7  0:00 ps -edf 
     jpp  67722  36206   0 08:49:51  pts/5  0:00 -ksh 
     jpp  67952      1   0 08:49:46      -  0:02 /usr/local/bin/pland -k 
     jpp  85608  69868   0 08:49:46      -  0:01 xmh 
     jpp  94304  69868   0 08:49:46      -  0:24 fvwm

nohup

at

• Si vous souhaitez ne lancer qu'une seule fois une commande à une heure particulière sur votre station, c'est possible avec at.

  ---

  $>at now +3 minutes
  find /home/jpp -name "core" -exec rm {} \;
  ^D
  $>
  $>echo who | at now +4 hours
  $>
  

  ---

  Pour plus d'informations : man at, la sortie de votre commande à l'exécution de at vous sera envoyée par mail !

  crontab

• Si vous souhaitez que l'exécution soit périodique et automatique (dans le cas de suppression de fichiers, de compression ou de sauvegarde de fichiers etc.), crontab sera la commande appropriée. Il est nécessaire d'avoir été autorisé par root pour utiliser cette commande.
  crontab accepte deux options:
  -l (pour lister les commandes déjà enregistrées);
  -e (pour éditer la liste des commandes enregistrées).
  Attention, édition sous vi par défaut, pour sortir :wq, modifiable par EDITOR).

  ---

  $>crontab -l
  20 3 8 * * /usr/local/bin/mon_script_de_sauvegarde
  0  8 * * 0 /home/jpp/bin/recup_mail
  

  ---

  Chaque ligne doit comporter 6 colonnes, si une colonne contient une astérisque, le champ devient non discriminant.
  • 1^ère : minutes (0-59)
  • 2^e : heures (0-23)
  • 3^e : jour du mois (1-31)
  • 4^e : mois (1-12)
  • 5^e : jour de la semaine (0-6,0 pour dimanche)
  • 6^e : nom de la commande ou du script

• Ou simplement passer un certain délai entre deux commandes, la commande sleep X permettra de différer de X secondes l'exécution de la commande suivante.

  ---

  $>echo debut;sleep 10;echo fin  
  debut
  fin
  

  ---

top

• de CPU empêchera le processeur de s'occuper de vous et de vos applications (tout sera figé ou extrêmement ralenti),
• de mémoire supérieure à la mémoire physique provoquera une pagination intense sur disque ralentissant les accès à la mémoire (puisqu'elle s'effectue alors sur disque avec un facteur >100).

DÉMO/TD (à faire avec plusieurs logins) Pour vous entraîner, utilisez la commande sous TP/TP2 commande_longue. Passez-la en arrière plan tout en la gardant active. Tuez-la avec un CTRL C. Lancez-la sans qu'elle se fasse tuer par votre déconnexion. Reconnectez vous et tuez-la par un kill.

Retour début

L'élaboration de scripts

Lorsqu'on a trois fichiers comme dans cet exemple, cela ne pose aucun problème, mais il est rare de faire tout un projet avec seulement trois fichiers. Il est plus fréquent d'avoir plusieurs dizaines de fichiers sources.

De plus il peut exister de multiples dépendances dans les codes sources via les fichiers include (les .h ou les modules Fortran 95). La gestion de la compilation, si elle est faite à la main, peut générer des erreurs sournoises en introduisant des incohérences.

Le fichier Makefile résout tous ces problèmes (en se basant sur les dates de modification) et automatise le travail (certaines compilations peuvent durer plusieurs heures...). Voyons comment fonctionne un makefile sur notre exemple. En fait la commande make appelle par défaut un fichier Makefile (avec un M). Le travail consiste donc à "remplir" dans le fichier Makefile les règles de dépendance, de compilation, les noms des fichiers et les options de compilation nécessaires.

Ce qui donne dans notre cas :

Ma_machine>cat Makefile
code : prog.o fic1.o fic2.o fic3.o
    f77 -o code prog.o fic*.o
prog.o : prog.f
    f77 -c prog.f
fic1.o : fic1.f
    f77 -c fic1.f
fic2.o : fic2.f
    f77 -c fic2.f
fic3.o : fic3.f
    f77 -c fic3.f

Remarques :

• les lignes contenant le caractère : sont appelée règle, à gauche de ce caractère se trouve la cible, à droite se trouvent les dépendances de la cible,
• en dessous de chaque de chaque règle se trouve les lignes de commandes qui vont permettre au shell de passer des dépendances à la cible,
• les lignes indentées (lignes de shell) commencent par une tabulation (TAB).

La structure générale du fichier Makefile est la suivante:

VARIABLE LOCALE1=VALEUR1
...
VARIABLE LOCALEn=VALEURn

CIBLE: DÉPENDANCES
       CONSTRUCTEUR de la CIBLE

Si une des DÉPENDANCES est obsolète ou inexistante, elle devient à son tour une CIBLE, et ainsi de suite ...

Dans un projet complexe ayant plusieurs dizaines/centaines de fichiers, il est impensable d'écrire un fichier Makefile à la main, on utilise plutôt les règles implicites du make.
Il est également possible d'utiliser des variables (ou macros). Ainsi au début du Makefile, les options sont écrites dans des variables d'environnement:
CF = f77 (si je souhaite changer de compilateur CF=f90)
FFLAGS=-g (si je ne souhaite plus déboguer FFLAGS=)
et même dans notre cas OBJS=prog.o fic1.o fic2.o fic3.o.
Ces macros doivent être utiliser via un $()

Notre exemple devient :

CF = f77
FFLAGS=-g
OBJS=prog.o fic1.o fic2.o fic3.o
code : $(OBJS)
   $(CF) $(FFLAGS) -o code $(OBJS)

prog.o : prog.f
   $(CF) -g -c prog.f
fic1.o : fic1.f
   $(CF) -g -c fic1.f
fic2.o : fic2.f
   $(CF) -g -c fic2.f
fic3.o : fic3.f
   $(CF) -g -c fic1.f

Les dépendances : attention, si fic2.f demande le fichier d'include inc.h, il faut que fic2.o dépende de inc.h, or par défaut make l'ignore... il faut donc rajouter :
fic2.o : fic2.f inc.h
Dans un vaste projet rajouter, à droite, à gauche des lignes dans le makefile n'est pas raisonnable.

cc -M

Pour nous aider, nous allons nous appuyer sur les compilateurs qui disposent de l'option -M, permettant de générer les dépendances

Ma_machine$>cc -M fic2.f
fic2.o : fic2.f inc.h /usr/include/f_pvm.h

Le makefile devient donc :

#Déclarations de variables
CF = f77
FFLAGS=-g
OBJS=prog.o fic1.o fic2.o fic3.o
MKDEP=-M
code : $(OBJS)
    $(CF) $(OBJS) -o $(@)
depend :
    $(CC) $(MKDEP) *.f > depend
include depend

Remarques :

• les caractères$@ ou $(@)   permettent de réutiliser le nom de la cible,
• les caractères$^  permettent de réutiliser les dépendances,
• le caractère \   permet de continuer la ligne de shell (attention pas de blanc après),
• le caractère #   permet d'inclure des commentaires,
• le caractère :   dans une macro permet de faire des substitutions.

Il est possible de rajouter encore quelques règles utiles pour faire du ménage, créer une bibliothèque ou tout générer comme :

clean:
        rm -f *.o ;\
        echo j'ai détruit tous les *.o
LIB=lib.a
$(LIB) : $(OBJ)
        ar -r $(LIB) $(OBJ)
all: depend code
        echo j'ai compilé tout ces fichiers : $(OBJ:.o=.f)

Attention : si vous souhaitez utiliser une variable d'environnement (comme $HOME, $TMPDIR) dans un makefile, il faut les faire précéder par $ (un autre $) comme suit :

 
install :
        cp $$HOME/source/*.f  $$WORKDIR

Pour déterminer quelles seront les actions effectuées par votre make (si vous avez un peu de mal à suivre les règles), sans les exécuter, utiliser l'option -n :
make -n all

Remarque : si vous avez changé un flag de compilation, et que la dernière compilation s'était bien passée, make ne fera rien ! En effet aucune règle lui impose de recommencer en cas de modification du fichier Makefile. Pour que make fonctionne, faites un touch *.f* qui mettra la date des *.f* à la date courante.
Autre solution : l'effacement des .o et de l'exécutable obligera aussi le make à tout recompiler.

Retour début

Quelques commandes Unix pour écrire des scripts

Il existe de multiples façons de faire des scripts, citons seulement awk, shell (ksh ou csh), perl etc.
Mais à quoi servent-ils ?
En fait, ils sont vos meilleurs amis en cas de traitements inhabituels. Quelques exemples de traitements "inhabituels" :

1. substitution d'une variable dans un code, la variable TEMP doit être remplacée par Temp_Locale, TEMP apparaît à de multiples endroits et sur plusieurs dizaines de fichiers source, comment faire ?
2. liste des couleurs et de leurs occurrences dans un fichier html;
3. déplacer des fichiers suivant certains critères.

Mais avant de vous lancer dans l'écriture de scripts, soyez sûr que le traitement que vous souhaitez réaliser ne soit pas déjà effectué par une commande unix ! (ça arrive TRÈS souvent au débutant !). Aussi avant de voir plus en détail l'implémentation des exemples cités plus haut, passons en revue quelques commandes unix puissantes encore non citées dans ce cours.

sort

sort : permet de trier les lignes d'un fichier (fic) suivant un champ particulier.

• sort fic : trie les lignes de fic dans l'ordre croissant
• sort -r fic : trie à l'envers
• sort -n fic : trie sur des valeurs numériques (123 est après 45)
• sort -t: +n fic : trie suivant le  n+1^e champ (champs séparés par des :)

uniq : permet de supprimer les lignes identiques et de les compter (attention les lignes doivent être triées)

paste : permet de "coller" deux fichiers l'un à côté de l'autre, c'est-à-dire d'ajouter le contenu de la ligne i du second fichier à la suite de la ligne i du premier fichier et cela pour toutes les lignes.
Ne pas confondre avec l'un derrière l'autre (cat fic >> fic2) qui met les lignes du fichier 2 derrière celles du fichier 1)

• paste fic1 fic2 >fic3
• paste -d\| fic1 fic2 > fic3
  pour mettre un | caractère de séparation entre la fin de la ligne du fichier 1 et avant le début de la ligne du fichier 2 et cela pour chaque ligne

cut : permet de "couper" une partie des lignes d'un fichier

• cut -c 3-10 fic : ne garde que le 3^e au 10^e caractères
• cut -c -10 fic : ne garde que le 1^er au 10^e caractères
• cut -c 3- fic : ne garde que le 3^e au dernier caractère
• cut -f 4,6 -d : fic : ne garde que le 4^e et 6^e champs (: étant LE caractère de séparation indiqué derrière -d, il doit être unique surtout avec le caractère "blanc")

tr : tr b-z a-y, sert à convertir le flux de caractères en remplaçant une lettre de la première liste par une autre de la deuxième liste (du même indice). Par exemple tr a-z A-Z permet de passer toutes les lettres d'un flux en majuscules.
Deux options intéressantes :

• -s '\000' qui supprime les caractères contigus passés en argument, ici les octets nuls,
• -s ' ' qui supprime les caractères contigus blancs,
• -d ':cntrl:' qui supprime tous les caractères de contrôle.

DÉMO/TD Recherchez la valeur identique (la plus grande possible et ayant la plus grande occurence) dans les fichiers commençant par mpp du répertoire TP/TP3. Et déterminez dans quels fichiers se trouve celle de plus grande occurrence. Réponse : echo "tpsu nqq* | vojr -d |tpsu -o | ubjm -o3 | dvu -d 7- | tpsu -o | ubjm -o1" | tr b-z a-y Réponse : echo "hsfq -o 281. nqq* | dvu -g 1 -e : | tpsu | vojr" | tr b-z a-y

Il est clair ici qu'un grand nombre de traitements peuvent être créés par la juxtaposition de commandes via des >, des | ou même des ; (l'enchaînement de commandes indépendantes peut être fait ainsi : cd;ls ).

Si malgré toutes ces commandes, certaines choses restent impossibles à faire, nous devons construire un script.
La première ligne du script doit (devrait) contenir #!/chemin/shell, afin de rendre votre script indépendant de votre shell courant, par exemple :
#!/bin/bash
ou
#!/usr/bin/perl
...
...
...

Les lignes qui précèdent sont des lignes de votre shell favori, un script sert seulement à mettre l'ensemble de ces lignes dans un fichier (mon_premier_script). Attention ce fichier doit avoir au moins les droits en exécution pour fonctionner. Lancez ensuite ./mon_premier_script

Retour début

L'interpréteur de commandes ou shell bash

Par exemple: ls -l *
liste selon l'ordre alphabétique le nom de tous les fichiers et répertoires du répertoire courant en précisant la date de leur dernière utilisation, leur taille, leur état, ...

L'interpréteur exécute la commande en créant un nouveau processus, dit processus fils, et attend la fin de son exécution avant de permettre la frappe d'une autre commande. Il suffit d'ajouter en fin de commande le caractère & pour que cette attente par le processus père de la fin de l'exécution du processus fils n'est pas lieue. Avec &, la commande est dite être exécutée en arrière-plan.

Exemple: xemacs sp.f   ouvre une fenêtre où s'exécute l'éditeur nedit, mais la fenêtre où nedit a été tapée n'est plus utilisable tant que l'exécution de xemacs ne sera pas terminée.
Par contre, la frappe de xemacs sp.f & ouvre la même fenêtre où s'exécute l'éditeur xemacs, mais, il reste possible de taper une nouvelle commande dans la fenêtre initiale.

L'interpréteur permet aussi de ranger dans un fichier une suite, une procédure de commandes et de les faire exécuter en invoquant le nom du fichier suivi des paramètres ce qui transforme cette procédure en une nouvelle commande. Ainsi, il est possible de créer un environnement sur mesure, adapté aux besoins.

Comment écrire une procédure de commandes ou script?

Les règles du langage de commandes:

L'écriture d'une telle procédure dans le fichier de nom, par exemple: commande , doit suivre les régles suivantes :

• toute variable est de type chaîne de caractères (non encadrées d'apostrophes et non séparées par des virgules)
• des structures de contrôles peuvent être utilisées
• les paramètres sont supposés initialisés à l'appel
• la procédure hérite des variables d'environnement
• # en première colonne entraine que le reste de la ligne est un commentaire.

Remarques :

• Une exception, toutefois, au commentaire #, la première ligne d'une commande #!/bin/sh ou #!/bin/bash ou ... lance l'exécution d'un processus sh ou bash qui peut être différent du shell par défaut (bash).
• Le fichier, pour être exécutable, doit avoir les droits d'accès r-x
  (sinon exécuter: chmod +rx [ugoa] commande)
• Pour chaque exécution, un nouveau processus (fils) est utilisé

L'appel de la commande se fait sous l'une des formes suivantes:

La Variable peut être utilisée dans la commande avec la Valeur précisée. Variable joue le rôle d'un paramètre nommé et non positionnel comme les autres.

ou bien encore
sh -v commande paramètre1 ... paramètreN redirections (chaque ligne de la commande, non interprétée, est affichée avant son exécution)

ou bien encore
sh -x commande} paramètre1 ... paramètreN redirections (chaque ligne de la commande est affichée, avant et après son interprétation)

La désignation des paramètres :

• - le nom de la commande, c'est à dire du fichier la contenant, est désignable par $0
• - le premier paramètre est désignable par $1
• - le second paramètre est désignable par $2 ...
• - la liste complète des paramètres est désignable par $*
• - le nombre de paramètres est désignable par $#
• - le numéro du processus en cours d'exécution est désignable par $$
• - le numéro du dernier processus exécuté avec & est désignable par $!
• - l'option de sh (-v ou -x ...) est désignable par $-
• - le code de retour d'une commande est désignable par $?

Exemple: Soit une procédure de commandes, stockée dans le fichier de nom chercher. Son appel sous la forme:     chercher MOT1 MOT2    entraine que

• $0 désigne chercher
• $1 désigne MOT1
• $2 désigne MOT2
• $* désigne MOT1 MOT2
• $# désigne 2

Les variables locales:

Elles n'ont pas à être déclarées. Il suffit de les initialiser. Par exemple:
VarLocale1=valeur1 VarLocale2=valeur2 ... La valeur de VarLocale1 est $VarLocale1 ou ${VarLocale1} ce qui en permet la concaténation avec tout autre texte. Pour rendre ces variables locales permanentes, il faut les "exporter" par
export VarLocale1 VarLocale2
Dès lors, ces variables deviennent des variables d'environnement.

Les variables d'environnement:

La procédure de commandes, lors de son exécution, hérite de l'environnement, et notamment, des variables d'environnement. Pour en obtenir la liste, il suffit de taper env. Le résultat de l'exécution de env, obtenu sur le PC aube est du type suivant:

PWD=/share/thot/users/dea-ana/martin
MEFISTO=/usr/local/mefisto
HOSTNAME=aube.edcsm.jussieu.fr
PVM_RSH=/usr/bin/rsh
QTDIR=/usr/lib/qt3-gcc2.96
LESSOPEN=|/usr/bin/lesspipe.sh %s
PS1=aube.edcsm.jussieu.fr:${PWD#} -bash-> 
XPVM_ROOT=/usr/share/pvm3/xpvm
USER=martin
LS_COLORS=no=00:fi=00:di=01;34:ln=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.gz=01;...
MAIL=/var/spool/mail/martin
INPUTRC=/etc/inputrc
LANG=fr_FR@euro
SSH_CLIENT=134.157.2.45 1023 22
DISPLAY=localhost:12.0
LOGNAME=martin
SHLVL=2
SHELL=/usr/local/bin/bash
CDPATH=/usr/local/mefisto:/share/thot/users/dea-ana/martin:.
HISTSIZE=1000
LAMHELPFILE=/etc/lam/lam-helpfile
PVM_ROOT=/usr/share/pvm3
HOME=/share/thot/users/dea-ana/martin
TERM=xterm
SSH_ASKPASS=/usr/libexec/openssh/gnome-ssh-askpass
PATH=/usr/kerberos/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin
MEFISTOX=/share/thot/users/dea-ana/martin/mefistox
SSH_TTY=/dev/pts/2
_=/usr/bin/env

Les structures de contrôle:

La séquence de commandes avec le séparateur;  :

De même,
commande1; commande2; ... commandeN
diffère de
( commande1; commande2; ... commandeN )
par le fait que, dans le second cas, un nouveau processus a été exécuté et pas dans le premier.

Par exemple : cd rep; ls
entraine que le nouveau répertoire de travail est rep, tandis que
(cd rep; ls) garde l'ancien répertoire actif en fin d'exécution du groupement de ces 2 commandes.

La boucle for:

Exemple : Le fichier boucle1 contient

for i in $*
do
  echo Le parametre est $i
done

Il faut donner au moins les droits d'accès r-x par la frappe de chmod 500 boucle1
Alors, la frappe de boucle1 a bb 45
affiche

Le parametre est a
Le parametre est bb
Le parametre est 45

Si le fichier boucle2 contient

for i in $*
do
  echo 'Le parametre est $i'
done

Le parametre est $i
Le parametre est $i
Le parametre est $i

Si le fichier boucle3 contient

for i in $*
do
  echo "Le parametre est $i"
done

Le parametre est a
Le parametre est bb
Le parametre est 45

Si le fichier boucle4 contient

for i in `ls $MEFISTO`
do
  echo "Le parametre est $i"
done

Le parametre est bin
Le parametre est doc
Le parametre est elas
Le parametre est incl
...
Le parametre est xvue

Il est possible de créer une liste de paramètres à partir des résultats de l'exécution d'une commande obtenus en encadrant l'appel de la commande par le caractère `
Par exemple: rep=`pwd` echo $rep donne /share/thot/users/dea-ana/martin/mefistox

La réaction du shell pour un caractère spécial encadré par un même caractère spécial est la suivante :
f signifie fin de chaîne   i signifie interprété    n signifie non interprété

Le caractère à interpréter ou non	'	"	`	\	$	*
Entre ' le caractère ci-dessus vaut :	f	n	n	n	n	n
Entre " le caractère ci-dessus vaut :	n	f	i	i	i	n
Entre ` le caractère ci-dessus vaut :	n	n	f	i	n	n

Remarques :
- Pour écrire une commande sur plusieurs lignes, il faut terminer chaque ligne, sauf la dernière par \ et sans aucun blanc derrière ou autre caractère. En effet, \ neutralise le caractère \nl de fin de ligne ce qu'il ne réalise pas si un caractère est situé entre \ et \nl . Par exemple

for i in `ls $MEFISTO`
do
  echo \
  "Le parametre est $i"
done

Les boucles conditionnelles while until:

Sa forme générale est
while commandes1
do
    commandes2
done
et
until commandes1
do
   commandes2
done

Dans le premier cas, commandes2 est exécuté si le code de retour de commandes1 est 0 (pas d'erreur). Dans le second cas, commandes2 est exécuté si le code de retour de commandes1 est >0.

break / continue Remarques :

• break fait sortir de l'exécution de la boucle for ou while ou until
  
• break 3 fait sortir de l'exécution de 3 boucles for ou while ou until imbriquées
  
• continue fait passer à l'itération suivante de la boucle
  
• continue 4 fait poursuivre l'exécution de la boucle 4 itérations plus loin.
  

Autres exemples: Pour les boucles sur des indices consécutifs on choisira une boucle while ainsi :

#!/bin/bash
i=1
while ((i<=5))
do
  qsub job.$i #Pour soumettre un job NQS sur une machine de calcul
  ((i=i+1))
done

Pour la lecture d'un fichier ou d'un flux (sortie de commande dans l'exemple) on pourra également choisir un while ainsi :

#!/bin/bash
ls | 
{
    while read ligne
    do
      echo $ligne
    done
}

Ou même en une seule ligne, on fait commande2 tant que commande1 est réussie

...
while commande1;do commande2;done
...

Le choix case:

Sa forme générale est
case $Var in
    option1) commandes1 ;;
    option2) commandes2 ;;
    ...
    optionm) commandesm ;;
    *) commandes ;;
esac

Si $Var vaut optioni, alors, les commandesi sont exécutées, puis, la commande au dessous de esac est exécutée. Le caractère * signifie "n'importe quel caractère" et cette option joue le rôle de sinon c'est à dire de tous les autres cas possibles.

Option peut être défini par
- plusieurs lettres entre [ ] ; par exemple:    [abcd]) echo $Var ;;
- plusieurs options avec le sens de OU ; par exemple:   -a|-b|-c) echo $Var ;;
- pour neutraliser un caractère spécial, il faut le précéder de \
Exemple:

case $REP in
  [hH]elp  ) echo j'ai tapé help;;
  go|run) echo le code démarre;;
  *     ) echo le reste;;
esac

Le test if:

Sa forme générale est
if commandes1
then
  commandes2
else
  commandes3
fi
commande4

Si le résultat de commandes1 (si plusieurs commandes sont exécutées alors le code efficace est celui de la dernière commande exécutée) est 0 (qui joue le rôle de vrai c'est à dire sans erreur d'exécution), alors, commandes2 sont exécutées, puis, commande4.
Si le résultat de commandes1 est différent de 0, alors les commandes3 sont exécutées, puis commande4. Cette option else est facultative.
Exemple:

cd
if test -d $MEFISTO
  ls $MEFISTO
else
  echo Pas de repertoire $MEFISTO
fi

De même,

if test -f $1
then
  :
else
  >$1
fi

if commandes1
then
  commandes2
else
  if commandes3
  then
    commandes4
  fi
fi

if commandes1
then
  commandes2
elif commandes3
  commandes4
fi

Exemple:

echo "Taper OUI ou NON : O/N"
read var
if [ $var = o ] || [ $var = O ]
then
  echo OUI
else
  echo NON
fi

Les tests peuvent porter aussi sur les chaînes ou l'état des fichiers avec [[ ]], ou sur les nombres avec (( ))

if (( numero < 10 )) || (( a != 2 ))
# liste d'opérateurs == != < > <= >=
then
echo "c'est plus petit"
else
echo "c'est plus grand"
fi

 
ou

read rep
if [[ $rep = "oui" ]]
#liste d'opérateurs = != < >
then 
rm -f *.h
fi

ou
 

if [[ ! -a mon_fichier ]]
#liste d'opérateurs -a (any) -f (fichier) -d (directory) -S (non vide)
#fic1 -nt fic2 (vraie si fic1 plus récent)
then cp $HOME/mon_fichier .
fi

Il est possible de faire des tests plus simplement. En effet chaque commande exécutée renvoie un code de retour (0=vrai ou 1=faux) qui peut être interprété par le shell.

Pour évaluer une opération en binaire (0 ou 1, 0 et 0, etc.) le shell se contente du minimum. S'il peut déterminer le résultat de l'opération sans connaître la deuxième opérande, il ne va pas s'en priver !

Dans le cas d'un ou,

• si la première commande se passe "bien", il ne cherchera pas à faire la deuxième et donc ne l'exécutera pas.
• Si la première commande a généré une erreur, le shell est obligé d'exécuter la deuxième commande.

Dans le cas d'un et c'est le contraire !

commandes1 && commandes2
exécute commandes2 seulement si le code d'erreur de commandes1 est 0 ce qui équivaut au test if sans la clause else.

commandes1 || commandes2
exécute commandes2 seulement si le code d'erreur de commandes1 est >0

Un ou est représenté par ||, et un et par &&. Voici des exemples appliqués au bash :

• grep XX file && lpr file  qui permet d'imprimer un fichier s'il contient XX
• ls mon_fichier && echo "mon fichier est bien présent "
• mon_code || echo "le code a planté !"
• commande || exit au sein d'un script

Quelques commandes supplémentaires:

Désignation du fichier de données d'une commande:

Le fichier (ou commande) de nom changer

vi $3 <<@
:1,\$s/$1/$2/g
:x
@

      SUBROUTINE TRTATA( M1 , M2 , L )
C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
C BUT : TRANSFERT DU TABLEAU M1 DE L MOTS DANS LE TABLEAU M2
C -----
C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
C AUTEUR : PERRONNET ALAIN UPMC ANALYSE NUMERIQUE PARIS    NOVEMBRE 1983
C2345X7..............................................................012
      INTEGER  M1(1),M2(1)
C
      DO 100 I = 1,L
         M2(I) = M1(I)
  100 CONTINUE
      END

donne le fichier modifié

      SUBROUTWNE TRTATA( M1 , M2 , L )
C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
C BUT : TRANSFERT DU TABLEAU M1 DE L MOTS DANS LE TABLEAU M2
C -----
C+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
C AUTEUR : PERRONNET ALAWN UPMC ANALYSE NUMERWQUE PARWS    NOVEMBRE 1983
C2345X7..............................................................012
      WNTEGER  M1(1),M2(1)
C
      DO 100 W = 1,L
         M2(W) = M1(W)
  100 CONTWNUE
      END

Segmentation du résultat d'une commande en plusieurs paramètres set:

set `date` ; echo $*; echo $6 $5 $4 $3 $2 $1
donne

mar sep 10 17:40:42 CEST 2002
2002 CEST 17:40:42 10 sep mar

Le texte résultat a été segmenté en 6 paramètres qui ont ensuite été affichés en sens inverse.

Dans une procédure
set -v conduit à l'affichage des lignes de la procédure au fur et à mesure de l'exécution ce qui équivaut à celui déjà vu de sh -v commande
set -x fait de même.
set - supprime les affichages dus à un appel précédent de set -v ou set -x.
set - * affecte à $1 le 1-er nom de fichier ou répertoire du répertoire de travail.

basename nom MotARetirer

Exemple: le fichier Ff

#!/bin/bash
#  Changer le suffixe des fichiers .F en le suffixe .f
echo     
echo MEFISTO: Changer .F en .f
echo =========================
echo Nom de la librairie de Mefisto?
read dir 
nomdir=$MEFISTO/$dir
cd $nomdir
rm *.bak
#
# boucle sur les fichiers .F
for i in `ls $nomdir | grep .F$`
do 
   nomsp=`basename $i .F`
   nomspF=$nomsp.F
   nomspf=$nomsp.f
   mv $nomspF $nomspf
done

MEFISTO: Changer .F en .f
=========================
Nom de la librairie de Mefisto?

Au total, cette procédure change en .f le suffixe .F des fichiers du répertoire indiqué (ici essai) de Méfisto.

Cet exemple montre de plus comment lire, c'est à dire récupérer dans la procédure la valeur d'une variable locale (ici dir) donnée par l'utilisateur, puis, comment l'employer. La variable nomsp contient le nom du fichier privé du suffixe .F

read NomVar1 NomVar2    lit sur l'entrée standard (clavier) une suite de mots. NomVar1 prend la valeur mot1. S'il y a plus de 2 mots alors NomVar2 reçoit le mot2 et tous les mots qui le suivent.

echo ${Var-}    affiche la valeur $Var si elle est initialisée et sinon le caractère .
echo ${Var?message}    affiche la valeur $Var si elle est initialisée et sinon message et l'exécution de la commande est terminée.
echo ${Variable?}    arrête l'exécution si la Variable n'est pas initialisée.

Manipulation des expressions arithmétiques avec expr:

La frappe de i=1
i=`expr $i + 1`
echo $i
donne
2

Les opérateurs logiques et arithmétiques standards sont utilisables .
Attention, les opérateurs doivent être encadrés de caractères blancs et les caractères spéciaux ( > , >= , <= , < , | , & , * , $ ) précédés du caractère \ pour ne pas être confondus avec le caractère spécial. Ils sont donnés ici dans l'ordre décroissant de leur priorité:
Ici, expr, expr1 et expr2 représentent chacun une expression.

( expr )    le groupe le plus interne est calculé en premier
expr1 % expr2    donne le reste de la division de expr1 par expr2
expr1 * expr2    et à égalité de priorité    expr1 / expr2
expr1 + expr2    et à égalité de priorité    expr1 - expr2

Si comp est l'un des opérateurs < , <= , = , != , >= , > alors, expr1 comp expr2    donne la valeur 1 si l'opération de comparaison numérique entre valeurs numériques ou lexicographique entre chaînes de caractères est vraie.

expr1 & expr2    donne la valeur de expr1 si expr1 et expr2 sont non nulles, sinon celle de expr2. expr1 | expr2    donne la valeur de expr1 si elle est non nulle, sinon celle de expr2.

exit

shift décale les paramètres d'un cran, $2 devient $1, $3 devient $2, ...

time commande donne le temps
- écoulé depuis le début de l'exécution de la commande
- consommé par l'unité centrale
- consommé par l'exécution de la commande.

Exemple: time `ls` affiche le contenu du répertoire courant puis {\tenttbis real 0m0.34s user 0m0.02s sys 0m0.04s}

wait fait attendre le processus père jusqu'à la fin de l'exécution de tous ses processus fils wait 1034 fait attendre jusqu'à la fin de l'exécution du processus 1034

size$MEFISTO/pp/ppmail   donne text data bss dec hex filename
1652803 81496 512463844 514198143 1ea60a7f ppmail
ppmail: 1652803 + 81496 + 512463844 = 514 198 143 octets c'est à dire la longueur du ``texte'' du fichier + la taille des données + la place possible dans la zone swap pour l'exécution + ... = la taille mémoire totale nécessaire à l'exécution

$? permet de déterminer si une commande s'est bien "passée", son code de retour est alors 0. Si elle a généré des erreurs, son code de retour est alors >0. Aussi n'est-il pas rare de voir dans un script :

...
commande_compliquee 
if (($? != 0))
then
  echo "pb sur commande_compliquee "
  break
else
  echo "ça marche ..."
fi
...

Rien ne vous empêche de créer vos propres variables (comme i ou rep). Comme vous l'avez vu dans les exemples précédents, une variable se définit par son NOM et s'appelle par $NOM ou ${NOM} si vous voulez l'insérer dans une chaîne de caractères (echo fic${i}ok).

Attention à la visibilité de ces variables. Elles ne sont pas vues à l'extérieur de votre script sauf si :

• vous avez utilisé export variable :
  export rep
  dans ce cas, elles seront visibles dans un sous-shell (un script dans un script).
• ou vous dites explicitement à ce script de ne pas créer de sous-shell lors de son lancement via . (point)
  . mon_script

Vous comprenez pourquoi, dans les fichiers de configuration (comme .bash_profile, .bashrc etc.) toutes les variables utiles à l'extérieur doivent être exportées et que ces scripts sont exécutés (ou réexécutés) via . (comme . .bash_profile).

Pour vous en persuader notez la différence entre set (positionnées) et env (positionnées et exportées).

Vous pouvez créer des sous-shells directement dans une ligne de commande en utilisant les parenthèses ( ) .

>pwd;(cd /;pwd);pwd
>/home/sos/jpp
>/
>/home/sos/jpp

Si vous faites un script avec des paramètres en entrée, comment les récupérer ?

• echo $# : pour connaître le nombre de paramètres
• echo $@ : pour avoir la liste des paramètres



---

for i in $@
do
  echo $i
done

---

• echo $0 : pour le nom de la commande
• echo $n : pour le paramètre de rang n ; il est possible de les décaler avec shift (sauf $0)
• echo $$ : pour le numéro du processus courant (très utile pour créer des fichiers temporaires /tmp/poub_$$)

Si vous souhaitez changer le contenu des $1, $2, $3 etc. utilisez set -- val0 val1 val3 ...

Ma_machine$>set -- 876 777 fin
Ma_machine$>echo $1 $2 $3
876 777 fin

• dans le traitement des chaînes de caractères :
  l'utilisation de % (suppression du pattern à droite) et # (suppression du pattern à gauche) sur une chaîne ma_chaine=/var/log/ma_log.old
  • Le doublement de % ou # en ## et %% permet de supprimer la plus longue chaîne exprimée par le pattern.
  • pour ne garder que le nom sans le chemin

    ---

    echo ${ma_chaine##*/}
    ma_log.old
    

    ---

  • pour changer le suffixe .old en .new

    ---

    echo ${ma_chaine%.*}.new
    /var/log/ma_log.new
    

    ---

  • pour éliminer le chemin d'accès d'un nom de fichier

    ---

    basename $ma_chaine
    ma_log.old
    

    ---

  (( ))

• pour le calcul de variables :
  comme nous l'avons déjà vu, l'utilisation des (( et )) autour de l'expression numérique permet de l'évaluer. Les opérateurs sont ceux habituellement utilisés dans d'autres langages : / % - + * (% pour le reste de la division euclidienne).
  echo mon resultat est : $((354%54))

• pour l'affectation conditionnelle d'une variable : il est possible d'initialiser une variable uniquement si celle-ci ne l'est pas déjà ! C'est souvent utile pour des scripts système dans un environnement utilisateur, ou le contraire.

  ---

  #lib positionnée par l'utilisateur
  LIB_MATH=/usr/local/lib_test
  
  #lib positionnée par le système dans un script 
  LIB_MATH=${LIB_MATH:=/usr/local/lib}
  
  #le résultat est bien conforme au choix de l'utilisateur
  echo $LIB_MATH
  /usr/local/lib_test
  

  ---

  
  $(cmd)
• Attention $(cmd) n'est pas une variable mais le résultat d'une commande cmd.

  ---

  Ma_machine$>ls
  Ma_machine$>titi toto tata
  Ma_machine$>result=$(ls tutu) 
  Ma_machine$>echo $result
  Ma_machine$>The file tutu does not exist.
  

  ---

nom_du_tableau[indice1]=champ1
nom_du_tableau[indice2]=champ2
nom_du_tableau[indice3]=champ3
...

set +A nom_du_tableau champ1 champ2 champ3

Ma_machine$>tab="zero" 
Ma_machine$>tab[1]="premier" 
Ma_machine$>tab[2]="deuxième" 
Ma_machine$>echo $tab
zero 
Ma_machine$>echo $tab[1]
zero[1] 
Ma_machine$>echo ${tab[1]}
premier 

La commande eval permet d'évaluer une ligne de commande

Ma_machine$>a='coucou'   
Ma_machine$>b=a   
Ma_machine$>echo $b
a      
Ma_machine$>echo \$$b
$a      
Ma_machine$>eval echo \$$b
coucou      
Ma_machine$>c=\$$b   
Ma_machine$>echo $c
$a      
Ma_machine$>eval c=\$$b   
Ma_machine$>echo $c
coucou      

Compléments sur la commande set :
L'écriture d'un script comme celle d'un programme peut devenir assez complexe si l'on ne dispose pas d'outils pour suivre l'évolution du code/script.

En bash, en utilisant set -v ce dernier affichera toutes les commandes exécutées avant transformation et après transformation si l'on utilise set -x . Pour annuler ces effets remplacer le - par un +.

Ma_machine$>set -v
Ma_machine$>set -x
set -x
Ma_machine$>ls titi
ls titi
+ ls titi
titi
Ma_machine$>ls *
ls *
+ ls tata titi tutu
tata  titi  tutu

Fonction: Comme dans de nombreux langages, vous pouvez créer vos propres fonctions. La syntaxe est la suivante :
nom_de_la_fonction () { liste; }
le blanc entre { et avant liste et le point virgule après liste sont obligatoires. Le code de retour est celui de la dernière commande exécutée dans la fonction. Il n'y a pas de nouveau process créé. De plus toutes les variables de la fonction sont partagées sauf si l'attribut "local" est précisé.
local nom_de_la_variable_locale=456

Ma_machine$>cdl () { cd $1;ls -lrt; } 
Ma_machine$>cdl Mail 
Ma_machine$>inbox info mbox 
Ma_machine$>pwd 
Ma_machine$>/home/jpp/Mail 

Remarque : ne jamais nommer son script "test", c'est une commande déjà vue dans if de Unix!

Quelques variables purement shell peuvent aussi être utiles, PRINTER pour définir par défaut le nom de votre imprimante, et SHELL pour le nom de votre shell favori.

Pour finir, voici un exemple de script impossible à faire en une ligne ! Il consiste à sauvegarder toute une arborescence et la transmettre de manière sûre à une autre machine, c'est-à-dire en se prémunissant contre certains problèmes comme :

• l'impossibilité de lire le fichier (les droits ne sont pas bons ou le fichier n'existe pas !),
• un débordement d'espace (file system full),
• l'indisponibilité de la machine de sauvegarde,
• l'accessibilité de cette même machine,
• la corruption des sauvegardes,
• croire que tout va bien et ne pas être au courant d'éventuels problèmes.

#!/bin/bash
set -x
LOGIN_DEST=jpp
MACHINE_SAUV=mira
REP_A_SAUV=/home/jpp/poster
MON_FIC=/home/sos/jpp/sauv_$(date '+%m_%d_%y')
tar SPclf - $REP_A_SAUV 2>/tmp/$$res_tar | \
rsh -l $LOGIN_DEST $MACHINE_SAUV "dd of=$MON_FIC" 
if [ $? = 0 ] && [ ! -a /tmp/$$res_tar ]
then
echo ça a marche !
rsh -l $LOGIN_DEST $MACHINE_SAUV "(mv sav1 sav2;mv $MON_FIC sav1)"
else 
echo pb dans la sauvegarde | mail jpp@idris.fr
mail jpp@idris.fr < cat /tmp/$$res_tar
rsh -l $LOGIN_DEST $MACHINE_SAUV "(rm $MON_FIC)"
fi
rm /tmp/$$res_tar

• date 'format' renvoie une chaîne de caractères représentant la date avec un certain format,
• l'option S du tar : permet de traiter les fichiers "troués",
• l'option P du tar : permet de ne pas supprimer le / en début de chemin,
• rsh : exécute une commande à distance sur $MACHINE_SAUV ,
• s'il y a eu un problème un mail est envoyé à l'auteur du script,
• le \ est le caractère de continuation de ligne.

Retour début

awk

1. avant le traitement du fichier, via BEGIN {print "avant"}
2. pendant, via {print "dedans"} (chaque ligne du fichier traité exécute cette partie)
3. après, via END {print x}

Quelques exemples pratiques :

• Affiche le 2^e et 4^e champs d'un fichier fic1 (pour chaque ligne) avec un format
  awk '{printf ("%-9s | %3s \n",$2,$4)}' fic1
• Affiche les champs 3 et 2 si le champ 1 contient URGENT et compte les occurrences
  awk 'BEGIN{x=0} $1 ~ /URGENT/ {print $3, $2 ; ++x} END{print "total" x}'  fic1
• Changement du séparateur de champs par défaut (" " ou TAB)
  awk 'BEGIN{FS=":"} print $1; print "la ligne complète est" $0' fic1
• Analyse des couleurs d'un document html (version 1)
  grep color unix_u_cours.html | awk 'BEGIN{FS="#"}{ print $2}' | cut -c1-6 | sort | uniq -c
• Analyse des couleurs d'un document html (version 2)
  awk 'BEGIN{FS="#"} $0 ~ /color/ {print substr($2,0,6) } ' unix_u_cours.html | sort | uniq -c
• Somme des éléments d'un fichier poub
  awk 'BEGIN{a=0} {a=a+$0} END{print a}' poub
• Moyenne des éléments communs d'un fichier poub (nom chiffre)
  awk 'BEGIN{NOM="";compteur=0;tot=0} { if ( $1 == NOM ) {tot=tot+$2;compteur=compteur+1} else { if (NR!=1) print tot/compteur,NOM ; NOM=$1;tot=$2;compteur=1} }END{print tot/compteur,NOM } ' poub

Chaque ligne du fichier traité est décomposée en champs ($1, $2, $3, ... ), la ligne entière est référencée par $0. Deux autres variables internes sont très utiles, NF pour le nombre de champs et NR le numéro du "record" (lignes en général).

Une multitude de fonctions existent comme cos, int, exp, sqrt, toupper, tolower etc.

Cas des structures de commandes :

• les décisions (if, else) dans un bloc de commande
  awk '{if ($2=="") { print $3} else {print $2} } END {print "fini"}' fic1
• les décisions en dehors d'un bloc de commande
  awk 'NF>=7 { print $3 }' fic1
  awk '$2 ~ /toto/ || $1=="URGENT" { print $3 }' fic1
• les boucles (while, for, do-while)
  awk '{i=4;while (i<=NF) { print $i; i++} }' fic1
  awk '{for (i=11;i>=0;i--) { print $i} }' fic1

• mono-dimensionnés :
  Tab[87]="milieu"
• associatifs :
  Tab["rouge"]=924

Si votre script fait quelques lignes, mettez-le dans un fichier et utilisez l'option -f de awk ainsi :
awk -f mon_script fic1

Il est possible de faire des choses très complexes avec awk, mais si vous avez plus de trois lignes à faire en awk, je vous conseille de passer à perl.

Retour début

perl

• perl -p -i -e "s|\bOLDNAME\b|NEWNAME|g;" `ls *.f *.F`
  permet en une seule ligne de changer OLDNAME en NEWNAME sur tous les fichiers sources Fortran du répertoire, et de répondre au cas 1 cité plus haut.
• pour ne récupérer que le texte situé entre deux mots (start et end) même s'ils ne sont pas sur la même ligne !
  perl -e "while (<>) {print if /start/ .. /end/}" fic
• la même chose mais pour les commentaires en C
  perl -e "while (<>) {print if /\/\*/ .. /\*\//}" fic

Perl peut utiliser des packages d'interface (modules) permettant d'accéder aux réseaux, aux bases de données,  aux analyseurs syntaxiques, etc. et faire ainsi en 3 lignes ce qui  nécessiterait autrement plusieurs milliers de lignes.

Voici un exemple de script utilisant un module réseau :

#!/usr/local/bin/perl -w
 
use Net::FTP;
$ftp = Net::FTP->new("truc.labo.fr");
$ftp-> login("login1","qpap?1");
 
$ftp2 = Net::FTP->new("machin.labo.fr");
$ftp2-> login("login2","qpap?2");
 
$pwd = $ftp->cwd("conftempo");
$pwd2 = $ftp2->cwd("respconftempo");
$ftp->type("I");
$ftp2->type("I");
 
@tab = $ftp->ls();
foreach $a (@tab) {
     $ftp->get($a);
     print ($a," recup ok\n");
     $ftp2->put($a);
     print ($a," transfert ok\n");
     $tmp=`rm -f $a`; }
$ftp->quit;
$ftp2->quit;
print ("fin du transfert");

Retour début

cpp

1. Les pseudo-constantes ou pseudo-fonctions: #define identificateur [chaîne-de-substitution]



---

#define  TAILLE 256
#define  TAILLE_EN_OCTETS TAILLE*sizeof(int)
#define NB_ELEMENTS(t) sizeof t / sizeof t[0]
main()
{
   int  tab[TAILLE];
   int  i;
   for(i=0; i < TAILLE; i++) tab[i] = i;
   printf("Le tableau tab contient %d octets\n",TAILLE_EN_OCTETS);
   printf("Le tableau tab contient %d octets\n",NB_ELEMENTS(tab);
}

---

    Pseudo-constantes déjà définies __DATE__ pour la date du jour, et __TIME__ pour l'heure.
 
2. La directive #include fichier_a_inclure permet d'insérer le contenu d'un fichier dans un autre.
3. Les directives #ifdef et #ifndef permettent de tester l'existence d'une pseudo-constante.



---

#ifdef identificateur
  partie-alors
[#else
  partie-sinon]
#endif

Exemple cpp prog.c > prog_a_compiler.c :


---

#ifdef DEBUG
  printf("je suis dans la boucle a l'indice %d \n",i);
#endif

---

Pour avoir un préprocesseur encore plus souple utilisez gpp (generic preprocessor http://auroux.free.fr/prog/gpp.html), vous pourrez ainsi définir vos propres macros et syntaxes.

DÉMO/TD Comment mettre en commentaire 100 lignes de code C sans utiliser les */ et /* à chaque ligne ? Sous TP/TP4.1 créer des images gif animées (comme celles utilisées pour ce cours) par un script. Générer des courbes xmgr d'après l'analyse/le traitement de fichiers de log sous TP/TP4.2

Retour début

Travailler sous X ...

Il permet de rendre totalement indépendants plusieurs aspects d'un système de fenêtrage et ainsi de développer des applications clientes des services de l'interface, indépendamment du matériel, du système d'exploitation, de la localisation de l'interface et de l'aspect de celle-ci.

Ce système rend donc également possible l'affichage de clients en provenance de plusieurs machines sur un écran unique (le serveur). Par dessus X11 viennent ensuite se greffer des window-managers ou gestionnaires d'interface qui determinent l'aspect et le mode d'interaction.

La terminologie X11 peut sembler contradictoire. En effet, un gestionnaire d'écran, comme une application, sont considérés comme des clients, et l'écran physique est lui considéré comme un serveur. En fait, il est assez normal que la couche offrant des services graphiques utilisés par des clients distants se nomme serveur. Le serveur est donc la machine sur laquelle l'affichage a lieu. Tout le reste n'est que client, y compris le gestionnaire d'interface. Les deux parties (client et serveur) peuvent très bien se trouver sur une même machine.

J'espère que vous travaillez déjà sous X ! Mais il est bon de rappeler que si c'est assez simple d'ouvrir une fenêtre X  en local sur votre écran, il est un peu plus complexe d'afficher chez vous la fenêtre d'un code tournant sur une autre machine. Le système X11 étant distribué, les clients peuvent donc venir de n'importe quelle machine du réseau, et sur ces machines de n'importe quel utilisateur. La couche de sécuritéde X11 a pour but de n'autoriser l'accès qu'a des machines ou des utilisateurs spécifiques.

Prenons le cas de votre laboratoire et de l'IDRIS. Vous travaillez chez vous et avez ouvert une fenêtre (suivie d'un rlogin ou d'un telnet ou d'un ssh) vers l'IDRIS. Dans cette fenêtre tourne un débogueur, un éditeur ou autre. Si ces outils sont X, vous obtiendrez inévitablement un message d'erreur comme suit :
Error: Can't open display:

Vous devez alors faire deux choses :

1. export DISPLAY=ma_machine.mon_labo.fr:0    sur la machine de l'IDRIS afin qu'elle sache où renvoyer cette fenêtre (DISPLAY est une variable du shell). A ce stade si vous essayez de nouveau vous obtiendrez un nouveau message :
   Xlib: connection to "ma_machine.mon_labo.fr:0.0" refused by server
   Xlib: Client is not authorized to connect to Server
   Error: Can't open display: ma_machine.mon_labo.fr:0
2. xhost + machine_IDRIS    sur votre machine locale, dans la fenêtre console, afin d'autoriser machine_IDRIS à s'afficher chez vous.
(Attention, ceci n'est pas complètement sans danger, utilisez plutôt xhaut pour plus de sécurité).

Ma_machine:>man ls | cat -v 



LS(1)                Cray Research, Inc.     SR-2011 9.0
N^HNA^HAM^HME^HE
     l^Hls^Hs - Lists contents of directory
S^HSY^HYN^HNO^HOP^HPS^HSI^HIS^HS
     l^Hls^Hs [-^H-1^H1] [-^H-b^Hb] 
     [-^H-B^HB] [-^H-c^Hc] [-^H-e^He] 
     [-^H-f^Hf] [-^H-F^HF] 
...

Ma_machine:>man ls
LS(1)      Cray Research, Inc.     SR-2011 9.0
NAME
     ls - Lists contents of directory
SYNOPSIS
     ls [-1] [-a] [-A] [-b] [-B] [-c] [-C] [-d] [-e] [-f] 
     [-k] [-I] [-l] [-L] [-m] [-n] [-o] [-p] [-P] [-q] [-r]
     [-u] [-x] [file ...]
...