IDRIS - CNRS Cours IDRIS : Unix_u
La version 2.2.6 de Jean-Philippe Proux est disponible en Version PostScript, Version PDF, Version HTML.

CNRS
Université Pierre & Marie CURIE
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

Ce cours a pour objectif de
- justifier l'emploi du système Unix;
- faire découvrir le système d'exploitation Unix;
- former le lecteur à sa pratique;
- permettre à chacun d'être plus efficace dans son travail sous Unix en utilisant les commandes appropriées.
A la fin du cours le lecteur pourra être considéré comme un utilisateur averti.

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 :
  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

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 tous les cas il vous faudra obligatoirement un login/password certifiant que vous avez les droits nécessaires pour vous connecter sur la machine après l'avoir atteinte.

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:

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

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 :

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).

  2. 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.

  3. 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).
  4. 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?

Trouver l'information n'est pas un problème, le plus dur est de se poser la ou les bonnes questions. La commande utile est man à faire suivre du nom de la commande_inconnue. Elle permet de tout connaître sur une commande ou un produit sous Unix (comme sa syntaxe ou ses options). En utilisant l'option -k vous pouvez chercher un mot clé particulier plutôt qu'une commande. Si la commande n'a pas de man, essayez les options -? ou -h à l'appel de votre commande.

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

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

Comment interpréter les symboles ci-dessus?

Cette syntaxe signifie que cmd peut être appelée de trois fois six manières différentes.

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

É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

Un fichier peut avoir 4 contenus:

Pour simplifier, nous nous intéresserons juste aux trois premiers dans ce cours, de plus nous appellerons répertoire le fichier représentant un répertoire !

Remarques sur le nom des fichiers:

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 !)

Les principales commandes d'Unix:

ls

Sous Unix, la commande la plus utilisée est, sans aucun doute, ls. Elle liste les fichiers et répertoires de votre répertoire courant.

Très souvent les fichiers cherchés sont les fichiers sur lesquels on travaille actuellement ou ceux récemment accédés. Nous n'avons donc aucun intérêt à les avoir par ordre alphabétique (par défaut), mieux vaut qu'ils soient classés directement par ordre chronologique croissant. L'ordre croissant est important, il permettra d'avoir les plus récents en dernier. En effet si vous avez plusieurs dizaines de fichiers, le résultat de la commande ne tiendra pas sur une seule page écran et vous serez obligé de jouer avec l'ascenseur de votre fenêtre pour voir ce qu'il y avait au début et cela, à chaque commande ls passée ! De plus, il est souvent indispensable de connaître les droits associés aux fichiers, ne serait-ce que pour savoir si c'est un fichier ou un répertoire. Aussi pour faire tout ça d'un coup, une seule commande ls -rtl.

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

La seconde commande plus utilisée est celle qui permet de copier un fichier vers un autre fichier ou vers un répertoire (le fichier originel restant en place).
Si l'option -R est précisée, il est possible de recopier un répertoire (et ses sous répertoires) dans un autre répertoire.
Ma_machine>cp fic1 fic2
Ma_machine>cp fic1 rep
Ma_machine>cp -R rep1 rep2

Retour début

mv

mv permet de changer le nom d'un fichier ou de le déplacer vers un autre répertoire.
Ma_machine>mv fic1 fic2  #(fic1 n'existe plus)
Ma_machine>mv fic1 rep  #(fic1 existe, mais sous rep)

Retour début

rm

rm permet de supprimer un fichier, ou un répertoire si l'option -r est précisée.
Pour éviter les confirmations multiples, l'option -f sera très utile.

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

Attention: rm, supprime réellement le fichier et il n'y a pas de restauration possible après.
Attention également au rm toto* mal écrit, un doigt qui fourche, qui glisse pour faire un rm toto *. avec un "blanc" entre toto et *   ==> PERTE de tous les fichiers du répertoire!

Retour début

cd

La commande cd permet de changer de répertoire. Le répertoire courant devient celui précisé.
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 :

Il est possible d'afficher en permanence la valeur du répertoire courant dans le prompt du shell. La variable d'environnement PS1 est affichée systématiquement comme prompt et PWD contient "en temps réel " la valeur du répertoire courant, en procédant ainsi :


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

Pour créer un répertoire, utiliser la commande mkdir mon_nouveau_repertoire.
Si vous voulez créer également tous les répertoires intermédiaires ajoutez l'option -p
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 problèmes d'accès aux fichiers et répertoires sont souvent mal perçus par les débutants. Pourtant les mécanismes de contrôle de lecture/écriture/accès d'un fichier ou répertoire sont simples, mais peuvent devenir un enfer si quelques points d'ombre subsistent.

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 1er 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 1er caractère, d'un w pour le 2e et d'un x pour le 3e, 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

Maintenant que tout est clair et que vous avez identifié les éventuels problèmes, la commande chmod va permettre de changer les droits des fichiers/répertoires. chmod utilise le codage binaire, fondé sur l'association de valeurs numériques aux différentes permissions : lecture : 4, écriture : 2, exécution : 1, pas de permission : 0.

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).

droitsvaleur octalevaleur binaire
---0000
--x1001
-w-2010
-wx3011
r--4100
r-x5101
rw-6110
rwx7111

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


chmod 750 fic1

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
 

Cette commande est très pratique quand vous souhaitez juste modifier des droits d'une catégorie à un ensemble de fichiers ayant des droits différents les uns des autres.

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

Si les fichiers que vous créez n'ont jamais les droits que vous souhaitez qu'ils aient, utilisez umask (taper la commande: man umask) pour obtenir sa syntaxe.

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

Si les droits sur le groupe sont corrects mais que le nom du groupe est incorrect, vous pouvez changer le nom du groupe d'un fichier via la frappe de la commande
chgrp[-R] new_grp fic|rep
Utiliser l'option-R pour le faire d'une manière récursive sur un répertoire.

chgrp MonGroupe fic1
chgrp -R MonGroupe MonRep

Retour début

chown

Il existe également une commande pour changer le propriétaire un fichier (mais seul root a ce privilège pour une raison évidente de sécurité)

chown [-R] new_owner fic|rep
chown jpp fic1

Retour début

Les commandes des ACL

Attention sur Linux, les ACL ne sont pas installées en standard et doivent être rajoutées par des paquets supplémentaires.

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

L'arborescence des fichiers sous Unix n'est pas si compliquée que ça. En fait cela dépend de votre degré d'organisation ou de celle de votre ingénieur système. Unix a un lourd passé, et garde des traces de son histoire au sein de son arborescence, mais essayons de clarifier tous ces répertoires.
/ là où tous les autres répertoires sont montés (accrochés) 
/bin  une partie des binaires du système et quelques commandes (ls, cat, rm ..) 
/home   partie où sont stockés les fichiers propres aux utilisateurs
/etc   quelques fichiers de configuration et des fichiers systèmes pour le démarrage 
/var   fichiers temporaires de quelques démons, de spools d'email et d'imprimantes, de logs, de locks ...
/opt  ou /usr/local lieu d'installation préféré des logiciels "modernes" 
/boot image du noyau pour Linux
/dev ensemble des devices (clavier, disques, cartes (son et réseau) etc.)
/usr    espace "standard" 
/usr/bin     pour les binaires
/usr/lib       pour les bibliothèques 
/usr/include     pour les "includes" (les .h)
/usr/local/bin   espace "non standard", rajout en local
/usr/local/lib     idem pour les bibliothèques
/usr/local/include     pour les "includes" 
/usr/local/src     pour les sources


Lors des installations, il vaut mieux que les fichiers binaires soient avec les binaires, les includes avec les includes et les lib avec les lib ! C'est simple à dire, mais pas forcément facile à faire, certains produits s'installent complètement sous /usr/src ou sous /opt et on se retrouve vite avec des bibliothèques et des includes dans tous les sens, ce qui est quasi impossible à gérer.

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

Dans le cas où des fichiers ne sont pas aux "bons" endroits, il faut être capable de les retrouver. Pour cela une seule commande, find. Elle paraît toujours un peu compliquée au début, mais on lui pardonne très vite, lorsqu'on découvre sa puissance !

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

Retour début

PATH

Maintenant que nous avons retrouvé le fichier que nous cherchions (sous /share/thot/users/dea-ana/martin/rep1/exe1), nous aimerions bien qu'il soit accessible simplement sans le chemin complet ! Pour cela, il suffit de rajouter ce chemin dans la variable PATH, dans votre .bash_profile sans écraser l'ancienne valeur de PATH :
export PATH=$PATH:/share/thot/users/dea-ana/martin/rep1

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

Parfois c'est le cas contraire, le shell "trouve" la commande, c'est-à-dire l'exécute sans problème, mais l'utilisateur, ignore où elle se trouve ; bien difficile alors de la modifier. En effet la variable PATH peut contenir un grand nombre de répertoires différents et rendre délicate la recherche de l'exécutable. Pour connaître le chemin exact de la commande exécutée, utilisez type :
type nom_commande
Elle précisera le chemin absolu utilisé pour exécuter nom_commande.

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

Bref, nous avons donc retrouvé tous les fichiers/commandes/scripts "perdus", mais malheureusement il arrive parfois que l'on ait 2 ou 3 fichiers quasiment identiques, des versions différentes d'un même code/script (~chgrp   et ~/bin/chgrp par exemple), ou bien des sorties d'un même travail, sans savoir vraiment ce qui les diffère. Imaginons que ces fichiers fassent plusieurs centaines de lignes, comment faire pour examiner leurs contenus ? Pour quelques centaines/milliers de lignes aucune solution manuelle... La solution rapide et efficace est diff, cette commande extrait uniquement les différences entre deux fichiers. Si 2 lignes diffèrent sur 10000 lignes,  seules ces deux lignes apparaîtront à l'écran !

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 ?

Après quelques semaines, vous désirez transporter sur votre PC personnelou sauvegarder sur disquette ou transférer votre travail à un membre de votre équipe. Mais voilà, tous les fichiers sont éparpillés sur votre disque...

Retour début

tar

Le premier réflexe est de les regrouper dans un seul répertoire (via un cp) puis de "tarer" ce répertoire, c'est-à-dire, de rassembler toute l'arborescence du répertoire en un seul fichier mon_boulot.tar. Si vos fichiers sont tous sous rep1 dans votre répertoire personnelHOME, alors vous pouvez utiliser dans votre HOME, la commande tar ainsi :
tar -cvf mon_boulot.tar rep1
le fichier mon_boulot.tar sera ainsi créé.

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 ...


Une fois votre fichier repéré, pour l'extraire de l'archive (et seulement lui) rajoutez-le à la commande habituelle :
tar -xvf mon_boulot.tar mon_fichier

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

Le fichier créé par un tar est souvent volumineux, il est alors judicieux de le compresser par de puissants outils afin de gagner de la place disque (60-70%) et du temps lors du transfert du fichier. Les deux compresseurs les plus souvent employés sont compress (standard Unix) et gzip (produit domaine public du GNU). Ce dernier a de grandes chances d'être déjà installé sur votre machine (automatiquement installé sous Linux), de plus, il est en général plus efficace que compress. La compression/décompression s'effectue ainsi :
 
commandes compression fichier compressé généré décompression
compress compress mon_boulot.tar mon_boulot.tar.Z uncompress mon_boulot.tar.Z
gzip gzip mon_boulot.tar mon_boulot.tar.gz gunzip mon_boulot.tar.gz

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

Cette commande, pas sécurisée, est de moins en moins permise. Elle est souvent remplacée par scp.
Maintenant, il reste à transférer le fichier "tar" sur la station du destinataire via ftp pour cela vous devez juste,

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

Comme nous en sommes aux interactions entre deux machines, détaillons un peu les Rcommandes. Attention: ces commandes, pas sécurisées, sont de moins en moins permises. Elles sont souvent remplacée par les Scommandes ssh scp ....

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

Ici, sur la machine_A peuvent se connecter sans taper de mot de passe, login_B depuis machine_B et observateur depuis eclipse. Attention, il est parfois nécessaire de préciser le chemin pour accéder (path) à la commande distante.

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

vi/emacs/xemacs/nedit

Le monde de l'édition est un monde encore plus conflictuel que celui des shells. Il existe de multiples éditeurs sous Unix, mais deux majeurs s'affrontent depuis 1975 ! Vi d'un côté (standard Unix) et Emacs (domaine public, à installer) de l'autre.

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.
CommandesFonctions
ibasculement en mode insertion
abasculement en mode ajout
cwmodification du mot courant
escsortie du mode d'insertion/ajout/modification
Jconcaténation de la ligne courante et de la suivante
xeffacement du caractère suivant
Xeffacement du caractère précédent
$déplacement en fin de ligne
0déplacement en début de ligne
ddsuppression de ligne et copie dans le buffer
dwsuppression de mot et copie dans le buffer
pcopie du buffer sous la ligne courante
Deffacement jusqu'à la fin de la ligne
.répétition de la dernière commande
uannulation de la dernière commande
hdéplacement vers la gauche
ldéplacement vers la droite
jdéplacement vers le bas
kdéplacement vers le haut
CTRL Fdéplacement sur la page suivante
CTRL Bdé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
qsortie de vi
q!sortie sans sauvegarde
xsortie avec sauvegarde
r ficinsertion de fic dans le fichier courant
! cmd_du_shellexécution d'une commande shell
%s/chaine1/chaine2/gsubstitution 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/gsubstitution de la 4e ligne à la ligne courante de chaine1 ou rexp par chaine2 (plusieurs fois par ligne)
s4,$/chaine1/chaine2/gcsubstitution de la 4e ligne à la fin de chaine1 ou rexp par chaine2 (plusieurs fois par ligne) avec confirmation (y,n,q)
g/chaine/lliste 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) 

Attention : le caractère "^P" représente un seul caractère : le caractère "Ctrl-p" et non pas "^" puis "P". Pour saisir ce caractère "Ctrl-p" sous l'éditeur emacs il faut taper la séquence de touches "Ctrl-q Ctrl-p"

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



Tous les shells acceptent des expressions régulières comme :

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 :

Retour début

sed/ed

Ils sont utilisés comme éditeurs non interactifs à base de commande vi.
sed lit les lignes d'un fichier une à une sans modifier le fichier source et applique le traitement souhaité.
ed travaille directement sur le fichier source.

Quelques exemples :

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


Un des principaux problèmes pour les débutants sous Unix, c'est d'arriver à gérer correctement les trois symboles : >(redirection de sortie), < (redirection d'entrée), | (pipe).

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

 

 

 

Deux exemples avec ces symboles

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

mon_script 
   
   
2>&1 
   
|
    
mail jpp@labo  

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

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

Retour début

xargs/sh

Pour exécuter un flux, la commande xargs peut vous aider :
-t pour avoir l'echo des commandes;
-n pour découper le flux d'entrée en paquets;
-i pour insérer le flux.

Retour début

grep

grep permet de rechercher les occurrences d'un mot ou d'un morceau de mot dans un fichier. Si vous voulez trouver toutes les personnes qui utilisent le ksh (bash sous linux) pour leur demander un petit conseil, sachez que le fichier /etc/passwd contient la liste des logins de votre machine avec, en particulier, le shell qu'ils utilisent. Il suffit de faire alors :

$>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

grep accepte des expressions régulières (comme *chaine, ^chaine, *toto*, chaine$) et accepte aussi de multiples options. On peut voir les expressions régulières comme des filtres, des masques agissant sur des chaînes de caractères. Les cinq options du grep les plus utiles sont :


Pour comprendre voici quelques exemples :

Liste des caractères spéciauxSignification pour les expressions régulières de grep,find,awk ou vi (en partie)Signification pour le shell
.caractère quelconque.
$fin de ligneidem
^début de ligneidem
[]un des caractères du crochetidem
-de ... à ds [x-y]idem
?expression régulière précédente optionnellecaractère quelconque
*répétition >=0chaî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

Votre code s'est exécuté et vous souhaitez savoir si tout s'est bien passé. Pour cela il suffit de "voir" la fin du contenu du fichier output (dans le cas d'un job) par la commande tail NomFichier (elle n'affichera que les 10 dernières lignes du fichier NomFichier).

Retour début


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

Lorsque vous utilisez des commandes ou vos programmes favoris sous Unix, ils s'exécutent systématiquement sous votre shell.
Tant que la commande s'exécute, vous n'avez plus la main, vous êtes bloqué. Certains utilisent plusieurs fenêtres pour continuer à travailler.

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 :

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 :


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

Prenons un exemple : avec Netscape, je n'ai plus de contrôle, le File/Exit ne réagit plus ! Ici Netscape a pour PID (process IDentification) 18032, pour s'en débarrasser :
kill 18032

nohup

Cas contraire : je souhaite que ma commande se déroule normalement alors que je voudrais me déconnecter. Si j'exécute une commande et que je sors de ma session (^D ou exit) la commande se terminera aussi ! Pour éviter cela, vous pouvez utiliser la commande nohup ainsi :
nohup ma_commande&
L'output de la commande ira dans un fichier nommé nohup.out et surtout vous pourrez vous déconnecter ! (plus de raison de laisser une session ouverte après votre départ).

at

Remarque : démarrage d'une commande à une heure donnée.

top

Pour surveiller toutes les anomalies sur votre station, la commande top (souvent installée par défaut) permet d'identifier les processus les plus consommateurs en temps CPU et en mémoire. En effet, seuls ces deux facteurs peuvent réellement perturber votre station. Une consommation excessive

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

La commande make

Lorsque l'on développe un programme (prog.f), il y a souvent plusieurs sous-programmes écrits dans de multiples fichiers dits sources (fic1.f, fic2.f, fic3.f etc). La phase de compilation consiste à générer les fichiers dits objets (les .o) et la phase d'édition de liens à créer un fichier dit exécutable (souvent a.out).
Ces deux étapes ne doivent pas être faites systématiquement de manière complète. En effet si l'on modifie fic2.f, il ne faut recompiler que fic2.f (et pas les autres fichiers !) et penser aussi à refaire l'édition de liens.

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 :


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)

En fait

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

sont des règles implicites déjà connues de make !

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

En fait inc.h dépendait lui même de pvm.h !
Attention c'est inefficace en Fortran 95 pour résoudre les dépendances de modules car la syntaxe use n'est pas interprétée par cpp)

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

Nous avons introduit une nouvelle règle depend qui ne dépend de rien, mais qui nous permet de faire make depend pour générer automatiquement le fichier depend qui sera rajouté (via include) au Makefile.

Remarques :

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.

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

  • uniq -c fic : compte les lignes identiques
  • 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)

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

    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 :

    voir la documentation avec la commande man.

    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

    L'interpréteur de commandes UNIX , encore dit SHELL (coquille en anglais) lit le nom de la commande et tout ce qui suit sert d'arguments à la commande exceptés certains caractères spéciaux appelés métacaractères & < > * ? | \ qui doivent être interprétés.

    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 :

    Remarques :

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

    commande paramètre1 paramètre2 ... paramètreN redirections
    Variable=Valeur commande paramètre1 paramètre2 ... paramètreN redirections

    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 :

    À l'intérieur de la procédure de commandes

    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

    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
    
    
    à lire sous la forme Variable=Valeur où Valeur est une chaîne de caractères. Comme les variables, la valeur de la variable d'environnement Var, s'écrit $Var Par exemple:
    $HOME est en fait ici: /share/thot/users/dea-ana/martin
    $PATH est en fait ici: /usr/kerberos/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin

    Les structures de contrôle:

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

    Les commandes peuvent être écrites séparées par le caractère ; sur une même ligne.
    Le passage à la ligne équivaut à une fin des paramètres de la commande de la ligne.
    commande1; commande2
    équivaut à
    commande1
    commande2

    Exemple : echo $SHELL; cd; ls;

    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:

    Sa forme générale est
    for var in Liste
    do
        commandes avec $var et/ou les variables d'environnement
    done
    exécute commandes avec la première valeur de la liste, puis, la seconde, ...
    Derrière in, vous pouvez mettre entre ` ` n'importe quelle commande dès lors qu'elle génère une liste d'éléments du même ordre. `cat fic1` ou `grep [0-9] fic1` peuvent convenir ou simplement une liste comme 1 20 50. Le traitement interne de la boucle peut être toute commande shell habituelle.

    Exemple : Le fichier boucle1 contient

    
    for i in $*
    do
      echo Le parametre est $i
    done
    
    et taper boucle1 a bb 45 donne boucle1: Permission denied

    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
    
    alors la frappe de boucle2 a bb 45
    donne
    Le parametre est $i
    Le parametre est $i
    Le parametre est $i
    
    La mise entre apostrophes a empéché l'interprétation de $i qui deviennent alors 2 caractères standards. La mise entre apostrophes neutralise l'interprétation des $var.

    Si le fichier boucle3 contient

    for i in $*
    do
      echo "Le parametre est $i"
    done
    
    alors la frappe de boucle3 a bb 45
    donne
    Le parametre est a
    Le parametre est bb
    Le parametre est 45
    
    $i est de nouveau interprété mais le caractère * entre les "" ne le serait pas.

    Si le fichier boucle4 contient

    for i in `ls $MEFISTO`
    do
      echo "Le parametre est $i"
    done
    
    alors la frappe de boucle4 affiche
    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
    
    donne le résultat précédent.

    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 :

    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
    
    donne
    bin doc elas incl mail ot poba pp reso td test ther util xvue

    De même,

    
    if test -f $1
    then
      :
    else
      >$1
    fi
    
    exécuté sous la forme
    test2 fichier
    ls -l fichier
    donne -rw-r--r-- 1 martin dea-ana 0 sept 5 13:22 fichier
    Le fichier de nom fichier a été créé vide car il n'existait pas dans le répertoire courant.
    Le caractère : est une commande vide retournant le code d'erreur 0 . Il permet ici de traiter la négation du test.
    test -d rep retourne 0 si le répertoire rep existe, un entier >0 sinon
    test -f fic retourne 0 si le fichier fic existe, un entier >0 sinon
    test ! -f fic retourne un entier >0 le fichier fic existe, 0 sinon
    test -r fic retourne 0 si le fichier fic existe et est ouvert en lecture, un entier >0 sinon
    test -w fic retourne 0 si le fichier fic existe et est ouvert en écriture, un entier >0 sinon
    test var retourne 0 si var n'est pas la chaîne vide, un entier >0 sinon

    
    if commandes1
    then
      commandes2
    else
      if commandes3
      then
        commandes4
      fi
    fi
    
    peut être écrit sous la forme équivalente
    
    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,

    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 :

    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
    @
    
    exécuté sur le fichier initial trtata.f
    
          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
    
    sous la forme de la frappe de    changer I W trtata.f

    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

    donne le nom amputé du 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
    

    La frappe de
    ls essai
    donne
    lxnmdc.F trtata.F
    Ff
    donne
    
    MEFISTO: Changer .F en .f
    =========================
    Nom de la librairie de Mefisto?
    

    La frappe de
    essai
    puis de
    ls essai
    donne
    lxnmdc.f trtata.f

    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

    arrête l'exécution et donne le code de retour de la dernière commande exécutée. exit 5    arrête l'exécution et donne le code de retour 5.

    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 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 ?

    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
    

    % / # / %% / ## Revenons aux variables afin de traiter quelques cas particuliers souvent rencontrés : Vous pouvez également définir des tableaux à une dimension ainsi :
    nom_du_tableau[indice1]=champ1
    nom_du_tableau[indice2]=champ2
    nom_du_tableau[indice3]=champ3
    ...
    

    ou plus synthétiquement :
    set +A nom_du_tableau champ1 champ2 champ3
    

    Pour utiliser un tableau attention aux {} :
    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 :


    #!/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
    
    

    Quelques lignes d'explications :
     

    Retour début

    awk

    awk permet de traiter des fichiers ligne à ligne et d'y associer un même traitement. awk divise éventuellement le travail en trois étapes :
    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 :

    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 :

    Il est possible de créer des tableaux :

    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 est un langage en soi, impossible de le décrire totalement ici. Il n'est pas en standard sur Unix (comme awk), il doit être installé. Cependant si vous avez la chance de l'avoir sur votre station, il peut, dans certains cas, vous permettre de faire des traitements assez complexes de manière simple. Voilà quelques "recettes de cuisine" utiles :

    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

    C'est le préprocesseur du C (donc disponible partout). Il exécute des instructions particulières appelées directives. Ces directives sont identifiées par le caractère # en tête. Ces directives sont de trois sortes :
    1. Les pseudo-constantes ou pseudo-fonctions: #define identificateur [chaîne-de-substitution]


    2. #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.
       
    3. La directive #include fichier_a_inclure permet d'insérer le contenu d'un fichier dans un autre.
    4. Les directives #ifdef et #ifndef permettent de tester l'existence d'une pseudo-constante.


    5. #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 ...

    X

    Le système de multifenêtrage X11, aussi appelé X window System, a été développé au MIT et est aujourd'hui l'interface graphique de la quasi totalité des ordinateurs sous Unix.

    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.
    3. (Attention, ceci n'est pas complètement sans danger, utilisez plutôt xhaut pour plus de sécurité).

    Dès lors vous devriez pouvoir afficher des fenêtres X chez vous.
    Attention, restent encore deux pièges dans certaines universités :

    1. il se peut que la connexion soit extrêmement lente (problème de bande passante), une fenêtre X peut mettre 5 minutes à arriver ! Pas de solution à part demander une augmentation du débit de la ligne.

      traceroute

      Ceci dit pour en être bien sûr, traceroute peut vous dire s'il y a un problème entre votre machine et la machine destination.

      • cas d'une ligne saturée :
        
        Ma_machine>traceroute www.koi.com 
        traceroute to www.koi.com (205.199.140.38)
         1  ipsgw2 (130.84.12.1)  2 ms  1 ms  1 ms
         2  ipsctl (130.84.164.1)  2 ms  1 ms  1 ms
         3  ipsgw1 (130.84.160.2)  2 ms  2 ms  2 ms
         4  ea-rerif-atm (192.54.202.19)  2 ms  2 ms  2 ms
         5  stlambert1.rerif.ft.net (193.48.53.213)  239 ms  13 ms  110 ms
         6  stamand1.renater.ft.net (193.48.53.9)  13 ms  4 ms  3 ms
         7  rbs2.renater.ft.net (195.220.180.18)  4 ms  3 ms  3 ms
         8  paii.renater.ft.net (195.220.180.29)  5 ms  7 ms  8 ms
         9  pos2.opentransit.net (193.55.152.25)  6 ms  5 ms  6 ms
        10  pos6.opentransit.net (193.55.152.90)  138 ms  138 ms  138 ms
        11  pos1.opentransit.net (194.206.207.54)  138 ms  138 ms  138 ms
        12  sl-stk-1-2.sprintlink.net (144.232.4.29)  138 ms  137 ms  140 ms
        13  sea-7-0.sprintlink.net (144.232.9.86)  149 ms  146 ms  146 ms
        14  sea-8-0-0.sprintlink.net (144.232.6.54)  319 ms  147 ms  147 ms
        15  semacorp-2-0-0.sprintlink.net (144.228.96.18)  158 ms  199 ms  189 ms
        16  10btin.aa.net (205.199.143.17)  195 ms  177 ms  195 ms
        17  www.koi.com (205.199.140.38)  208 ms  204 ms  244 ms
        
        
        
      • cas d'une ligne quasiment bloquée :
        
        Ma_machine>traceroute ftp.lip6.fr
        traceroute to nephtys.lip6.fr (195.83.118.1), 30 hops max, 40 byte packets
         1  ipsgw2 (130.84.12.1)  2 ms  2 ms  1 ms
         2  ipsctl (130.84.164.1)  2 ms  2 ms  1 ms
         3  ipsgw1 (130.84.160.2)  2 ms  2 ms  2 ms
         4  ea-rerif-atm (192.54.202.19)  2 ms  2 ms  2 ms
         5  stlambert1.rerif.ft.net (193.48.53.213)  3 ms  3 ms  3 ms
         6  u-jussieu-paris-atm.rerif.ft.net (193.48.53.198)  6 ms  4 ms  6 ms
         7  r-jusren.reseau.jussieu.fr (134.157.255.126)  80 ms  543 ms  731 ms
         8  * * *
         9  * * *  
         
         
         
    2. il se peut aussi que la connexion ne se fasse tout simplement pas ; dans ce cas c'est souvent un problème de filtre en interne chez vous (voyez votre ingénieur système / réseaux).

      ping

      Pour vérifier un simple ping machine_b vous permettra de savoir si machine_b est accessible ou pas !

      • cas accessible (demande de trois échos):
        
        Ma_machine>ping -c 3 www.ibm.com    
        PING www.ibm.com: (204.146.18.33): 56 data bytes
        64 bytes from 204.146.18.33: icmp_seq=0 ttl=235 time=131 ms
        64 bytes from 204.146.18.33: icmp_seq=1 ttl=235 time=125 ms
        64 bytes from 204.146.18.33: icmp_seq=2 ttl=235 time=133 ms
        
        
        
      • cas d'indisponibilité (www.ibm.com n'est pas dans les filtres.)
        
        Ma_machine:>ping www.ibm.com       
        PING www.ibm.com: 56 data bytes
        
        
        blocage --> sortie avec un ^D
        
        

    Retour début

    Un peu de sécurité

    Si votre compte est piraté, vous risquez de :


    passwd

    Le changement des passwd peut être laborieux, surtout si vous avez un compte sur plusieurs machines ; il l'est d'autant plus qu'il est assez fréquent (changement toutes les 10 semaines ; peut varier suivant les sites). Si la contrainte du renouvellement du passwd ne peut être évitée pour des raisons de sécurité, la répétition sur n machines peut être supprimée grâce à Passwd (avec un P). La commande Passwd est disponible sur Rhodes (et donc uniquement à l'IDRIS) et propagera votre login (qui doit être inférieur à 8 caractères) sur l'ensemble des machines de l'IDRIS. Sachez que des commandes standard existent comme yppasswd pour faciliter la propagation des mots de passe.

    Comment faire pour trouver un bon mot de passe ?
    Surtout ne pas utiliser son nom, son prénom et même aucun prénom ou nom classique. Les pirates utilisent des dictionnaires pour "cracker" les mots de passe, alors bannissez tous les mots du dictionnaire même étrangers ! De plus maintenant avec un "simple" ordinateur portable un mot de passe de moins de 8 caractères est "cassable" en moins de deux jours.

    Alors comment faire ?
    Il suffit de créer des mots à vous ! le plus simple est de créer une phrase que vous affectionnez particulièrement ou qui vous touche en ce moment et d'en extraire les premières lettres de chaque mot, c'est très efficace et inviolable. Évitez aussi les caractères spéciaux, certaines machines n'apprécient pas !

    Par exemple :
    un cours unix en préparation en 98 devient : 1cuepe98
    Il fait toujours mauvais a Paris ! : IftmaP!

    Remarque : ne pas utiliser des caratères comme # ou @ dans votre mot de passe car ils sont parfois interprétés par certaines commande comme telnet.

    Retour début

    s[cp|login|sh]

    Les scommandes offrent les mêmes fonctionnalités que les rcommandes mais en beaucoup plus sûres, en imposant un cryptage et une authentification plus robuste.

    Comment fonctionnent-elles ?

    Retour début

    Divers

    Voir des choses cachées

    Il est possible de découvrir :

    Retour début

    Ou le contraire, ne pas les voir

    Supprimer des choses indésirables comme les balises de style des man qui tabulent ou passent en gras certains caractères. Essayez d'imprimer un man, vous allez tout de suite comprendre...

    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 ...] ...

    Afin d'éviter d'avoir la première sortie (avec tous les ^H et ^C) sur votre papier, utiliser col -b ainsi :
    man ls | col -b | lpr
    La commande col agira comme un filtre prenant à gauche (standard in) un flux "pollué" venant de man et délivrant à droite (standard output) un flux débarrassé des différents caractères de contrôle à la commande d'impression lpr.
    Une autre option utile de la commande est -x qui transforme les TAB dans un fichier en "blanc".

    Retour début

    Commandes inclassables ou plutôt système

    Retour début

    Quelques références bibliographiques

    Bon travail en mettant en pratique tous ces conseils et astuces.