Page suivante Page précédente Table des matières

2. Les fichiers et les programmes

2.1 Les fichiers : notes préliminaires

Linux a un système de fichiers, ce qui signifie ``la structure des répertoires et des fichiers qui s'y trouvent', très similaire à celui de DOS. Les fichiers ont des noms qui obéissent à des règles spéciales, sont disposés dans des répertoires, certains sont exécutables, et parmi ceux-ci la plupart ont des options. De plus, vous pouvez utiliser les caractères ``joker'', faire des redirections et des enchaînements de commandes. Il n'y a que quelques différences mineures :

  • sous DOS, les noms de fichiers sont de la forme 8.3; ex. SUFFITPA.TXT. Sous Linux, on peut faire mieux. Si vous avez installé Linux en utilisant un système de fichiers de type ext2 ou umsdos, vous pouvez utiliser des noms de fichiers plus longs (jusqu'à 255 caractères), et qui comportent plus d'un point : par exemple Ceci_est.un.TRES_long.nom.de.fichier. Notez que j'ai utilisé aussi bien des majuscules que des minuscules : en fait...
  • dans un nom de fichier ou une commande, les majuscules et les minuscules sont différenciées. Donc, NOMDEFICHIER.tar.gz et nomdefichier.tar.gz sont deux fichiers différents. ls est une commande, LS est une erreur;
  • bien entendu, les utilisateurs de Windows 95 voudront utiliser les noms de fichiers longs sous Linux. Si un nom de fichier contient des espaces (ce qui est possible mais pas recommandé), vous devez entourer le fichier par des guillemets à chaque fois que vous y ferez référence. Par exemple:
    $ # la commande qui suit cree un repertoire appelle "Mes vieux fichiers"
    $ mkdir "Mes vieux fichiers"
    $ ls
    Mes vieux fichiers   bin   tmp
    
    Certains caractères peuvent être utilisés, mais ne devraient pas l'être, comme : !*$&. Toutefois, je ne dirais pas comment.
  • il n'y a pas d'extensions obligatoires pour les programmes comme .COM et .EXE, ou pour les fichiers batch comme .BAT. Les fichiers exécutables se terminent par une astérisque '*' lorsque vous faites la commande ls -F. Par exemple :
    $ ls -F
    lettre_a_Joe  cindy.jpg  cjpg*  Je_suis_un_repertoire/  mon_1er_script*  old~
    
    Les fichiers cjpg* et mon_1er_script* sont exécutables--- des ``programmes''. Sous DOS, des fichiers de sauvegarde se terminent par .BAK, alors que sous Linux, ils se terminent par une tilde '~'. En outre, un fichier dont le nom commence par un point est considéré comme caché. Exemple : le fichier .Je.suis.un.fichier.cache ne figurera pas dans la sortie de la commande ls;
  • Sous DOS, les options des programmes sont spécifiés avec /option, sous Linux il s'agit de -option ou --option. Exemple : dir /s devient ls -R. Remarquez que de nombreux programmes DOS, comme PKZIP ou ARJ, utilisent les options à la manière d'UNIX.

Vous pouvez maintenant vous rendre à la Section Traduction des commandes DOS vers Linux, mais, à votre place, je poursuivrais la lecture ici.

2.2 Les liens symboliques

UNIX dispose d'un type de fichier qui n'existe pas sous DOS : le lien symbolique. On peut le voir comme un pointeur sur un fichier ou sur un répertoire, et il peut être utilisé en lieu et place du fichier ou du répertoire sur lequel il pointe; cela ressemble aux raccourcis de Windows 95. Des exemples de liens symboliques sont /usr/X11 qui pointe sur /usr/X11R6; /dev/modem qui pointe soit sur /dev/cua0 ou /dev/cua1.

Pour créer un lien symbolique :

$ ln -s <fichier_ou_rep> <nom_du_lien>

Example :

$ ln -s /usr/doc/g77/DOC g77manual.txt

Maintenant, vous pouvez utiliser g77manual.txt au lieu de /usr/doc/g77/DOC. Les lignes apparaissent comme suit dans l'inventaire des répertoires:

$ ls -F
g77manual.txt@
$ ls -l
(diverses choses...)           g77manual.txt -> /usr/doc/g77/DOC

2.3 Droits et propriétés

Les fichiers et répertoires DOS ont les attributs suivants : A (archive), H (caché), R (lecture seule) et S (système). Seuls H et R ont un sens sous Linux : les fichiers cachés commencent par un point, et pour ce qui est de l'attribut R, lisez ce qui suit.

Sous UNIX, un fichier a des ``droits'' et un propriétaire qui appartient à un ``groupe''. Considérez cet exemple :

$ ls -l /bin/ls
-rwxr-xr-x  1  root  bin  27281 Aug 15 1995 /bin/ls*

Le premier champ contient les droits du fichier /bin/ls, qui appartient à root et au groupe bin. Si l'on ne tient pas compte du reste de l'information (il y a le livre de Matt pour cela), souvenez-vous que -rwxr-xr-x signifie (de gauche à droite) :

- est le type du fichier (- = fichier ordinaire, d = répertoire, l = lien etc...); rwx sont les droits pour le propriétaire du fichier (r=read=lecture, w=write=écriture, x=exécution); r-x sont les droits pour le groupe auquel appartient le propriétaire (lecture, exécution); (je n'aborderai pas le concept de groupe, tant que vous serez débutant(e), vous pouvez vous en passer ;-) r-x sont les droits pour tous les autres utilisateurs (lecture, exécution).

Ainsi, vous ne pouvez pas effacer le fichier /bin/ls à moins d'être root : vous n'avez pas les droits pour le faire. Pour changer les droits d'un fichier, la commande est :

$ chmod <quiXdroits> <fichier>

où 'qui' est u (user, c.à.d le propriétaire), g (groupe), o (other, les autres), 'X' est soit + ou -, 'droits' est r (lecture), w (écriture) ou x (exécution). NdT. : de plus, la lettre 'a' est un raccourci pour désigner à la fois 'u', 'g' et 'o'. Exemples :

$ chmod u+x fichier

ceci met les droits d'exécution pour le propriétaire du fichier.

$ chmod go-wx fichier

ceci enlève les droits d'écriture et d'exécution pour tout le monde sauf le propriétaire.

$ chmod ugo+rwx fichier

ceci donne les droits de lecture d'écriture et d'exécution à tout le monde.

# chmod +s fichier

ceci fabrique un fichier appelé ``setuid'' ou ``suid'' --un fichier que tout le monde peut exécuter avec les droits du propriétaire du fichier.

Un moyen plus court pour désigner les droits est d'utiliser des nombres : rwx-xr-x peut s'écrire 755 (chaque lettre correspond à un bit : --- vaut 0, --x vaut 1, -w- vaut 2, -wxvaut 3...). Cela paraît compliqué, mais avec un peu de pratique, vous comprendrez le concept. NdT. : la notation chiffrée des droits est faite en octal, donc 7 correspond au nombre binaire 111 où les 3 bits indiquant les permissions sont positionnés.

root, appelé également le super-utilisateur, peut changer les droits des fichiers quelque soit leur propriétaire. Il y aurait plus à en dire---LPM.

2.4 Traduction les commandes DOS vers Linux

A gauche, les commandes DOS; à droite, leurs équivalents Linux.

COPY :          cp
DEL :           rm
MOVE :          mv
REN :           mv
TYPE :          more, less, cat

Les opérateurs de redirection et d'enchaînement de commandes : < > >> |

Les jokers : * ?

nul : /dev/null

prn, lpt1 : /dev/lp0 ou /dev/lp1; lpr

- EXEMPLES -

DOS                                     Linux
---------------------------------------------------------------------

C:\GUIDO>COPY JOE.TXT JOE.DOC           $ cp joe.txt joe.doc
C:\GUIDO>COPY *.* TOTAL                 $ cat * > total
C:\GUIDO>COPY FRACTALS.DOC PRN          $ lpr fractals.doc
C:\GUIDO>DEL TEMP                       $ rm temp
C:\GUIDO>DEL *.BAK                      $ rm *~
C:\GUIDO>MOVE PAPER.TXT TMP\            $ mv paper.txt tmp/
C:\GUIDO>REN PAPER.TXT PAPER.ASC        $ mv paper.txt paper.asc
C:\GUIDO>PRINT LETTER.TXT               $ lpr letter.txt
C:\GUIDO>TYPE LETTER.TXT                $ more letter.txt
C:\GUIDO>TYPE LETTER.TXT                $ less letter.txt
C:\GUIDO>TYPE LETTER.TXT > NUL          $ cat letter.txt > /dev/null
        n/a                             $ more *.txt *.asc
        n/a                             $ cat section*.txt | less

Notes :

  • * est plus malin sous Linux : * correspond à tous les fichiers, sauf les fichiers cachés; .* correspond à tous les fichiers cachés; *.* correspond seulement à ceux qui ont un '.' au milieu, suivi d'autres caractères; p*r correspond à la fois à `par' et `pour'; *c* correspond à la fois à `secher' et `bocal';
  • lors de l'utilisation de more, appuyez sur ESPACE pour parcourir le fichier, 'q' ou CTRL-C pour quitter. less est plus intuitif et vous permet d'utiliser les flèches;
  • il n'y a pas de UNDELETE alors réflechissez-y à deux fois avant d'effacer quoi que ce soit.
  • en plus des < > >> du DOS, Linux connaît 2> pour rediriger les messages d'erreur (stderr); de plus, 2>&1 redirige stderr vers stdout, alors que 1>&2 redirige stdout vers stderr; NdT.: stdout est ``la sortie standard'' (le lieu où sont envoyés tous les messages qui ne sont pas des messages d'erreur); stderr est la ``sortie erreur standard'' (lieu où sont envoyés tous les messages d'erreur).
  • Linux a un autre caractère joker : le []. Utilisation : [abc]* correspond à tous les fichiers commençant par a, b, c; *[I-N123] correspond aux fichiers se terminant par I,J,K,L,M,N,1,2,3;
  • il n'y a pas de RENAME identique à celui du DOS; en fait, mv *.xxx *.yyy ne marchera pas. Vous pourriez essayer ce script simple; cf. la section Les shell-scripts pour plus de détails.
    #!/bin/sh
    # ren: renomme plusieurs fichiers selon certaines regles
    
    if [ $# -lt 3 ] ; then
      echo "usage: ren \"motif\" \"remplacement\" fichiers..."
      exit 1
    fi
    
    vieux=$1 ; nouveau=$2 ; shift ; shift
    
    for file in $*
    do
      new=`echo ${file} | sed s/${vieux}/${nouveau}/g`
      mv ${file} $vieux
    done
    

    Attention: ce script ne se comporte pas comme le REN du DOS, puisqu'il utilise des ``expressions régulières'' que vous ne connaissez pas encore. En bref, si vous voulez simplement changer l'extension de certains fichiers, utilisez le comme suit: ren "htm$" "html" *htm. N'oubliez pas le signe $.
  • utilisez cp -i et mv -i pour être averti(e) lorsqu'un fichier est sur le point d'être écrasé.
  • utilisez cp -i et mv -i pour être averti lorsqu'un fichier risque d'être écrasé.

2.5 L'exécution de programmes : le multitâche et les sessions

Pour faire tourner un programme, entrez son nom comme vous le feriez sous DOS. Si le répertoire (section Répertoires) où se trouve le programme est inclus dans le PATH (section Démarrage du système), le programme démarrera. Attention : au contraire du DOS, sous Linux, un programme situé dans le répertoire courant ne sera pas lancé à moins que ce répertoire ne soit inclus dans le PATH. Solution : si prog est votre programme, tapez ./prog.

Voici à quoi ressemble une ligne de commande typique:

$ commande -o1 -o2 ... -on par1 par2 ... parm < entree > sortie

-o1, ..., -on sont les options de la commande, et par1, ..., parm ses paramètres. Vous pouvez spécifier plusieurs commandes sur la ligne de commande:

$ commande1 ; commande2 ; ... ; commanden

C'est à peu près tout en ce qui concerne l'exécution des programmes, mais on peut facilement franchir un pas de plus. L'une des raisons principales d'utiliser Linux est que c'est un système d'exploitation multitâche--il peut faire tourner plusieurs programmes (que nous appellerons processus à partir de maintenant) en même temps. Vous pouvez lancer des processus en arrière-plan et continuer à travailler sans aucune gêne. De plus, Linux vous permet d'avoir plusieurs sessions : c'est comme d'avoir plein d'ordinateurs à la fois pour travailler !

  • Pour passer de la session 1..6 :
    $ ALT-F1 ... ALT-F6
    
  • Pour commencer une nouvelle session sans quitter la session courante :
    $ su - <nom de login>
    
    Exemple :
    $ su - root
    
    Ceci est utile, par exemple, lorsque vous avez besoin de monter une disquette (section Les disquettes) : en temps normal, seul root peut le faire.
  • Pour terminer une session :
    $ exit
    
    S'il y a des jobs arrêtés (lire plus loin), vous en serez averti(e).
  • Pour lancer un processus en avant-plan :
    $ nomdeprogramme [-options] [parametres] [< entree] [> sortie]
    
  • Pour lancer un processus en arrière-plan, ajoutez une éperluette '&' à la fin de la ligne de commande :
    $ nomdeprogramme [-options] [parametres] [< entree] [> sortie] &
    [1] 123
    
    le shell identifie le processus à un numéro de job (ex. [1]; cf. ci-dessous), et à un PID (123 dans notre exemple).
  • Pour voir combien il y a de processus :
    $ ps -a
    
    Ceci affichera une liste des processus en train de tourner.
  • Pour tuer un processus :
    $ kill <PID>
    
    Vous pourrez avoir besoin de tuer un processus lorsque vous ne savez pas comment le quitter proprement... ;-). Parfois, un processus ne pourra être tué qu'en faisant ceci :
    $ kill -15 <PID>
    $ kill -9 <PID>
    
    En plus de ceci, le shell vous permet d'arrêter ou de suspendre temporairement un processus, d'envoyer un processus en arrière-plan et d'amener un processus de l'arrière-plan vers le premier plan. Dans ce contexte, les processus sont appelés des ``jobs''.
  • Pour voir combien il y a de jobs :
    $ jobs
    
    ici, les jobs sont identifiés par leur numéro de job, et non par leur PID.
  • Pour arrêter un processus qui tourne au premier plan (cela ne marchera pas toujours) :
    $ CTRL-C
    
  • Pour suspendre un processus qui tourne au premier plan (même remarque) :
    $ CTRL-Z
    
  • Pour envoyer un processus suspendu en arrière-plan (il devient alors un job) :
    $ bg <job>
    
  • Pour amener un job vers le premier plan :
    $ fg <job>
    
  • Pour tuer un job :
    $ kill <%job>
    
    ou <job> peut être 1, 2, 3, ... (NdT. : ce paramètre est optionnel s'il n'y a qu'un seul job.) A l'aide de ces commandes, vous pouvez formater un disque, comprimer un lot de fichiers, compiler un programme, décomprimer et archiver tout à la fois tout en gardant une invite à votre disposition. Essayez de faire ceci sous DOS ! Et essayez avec Windows, rien que pour voir la différence de performance.

2.6 L'exécution de programmes sur des ordinateurs distants

Pour faire tourner un programme sur une machine distante dont l'adresse IP est grossebecane.distante.fr, faites :

$ telnet grossebecane.distante.fr

Après vous être connecté, démarrez votre programme favori. Il va sans dire que vous devez avoir un compte sur la machine distante.

Si vous disposez de X11, vous pouvez même faire tourner une application X sur un ordinateur distant, avec affichage sur votre écran X. Supposons que la machine X distante soit grossebecane.distante.fr et que boite.linux.locale soit votre machine Linux. Pour faire tourner un programme X résidant sur grossebecane.distante.fr à partir de boite.linux.locale, faites ce qui suit :

  • démarrez X11, lancez un xterm ou un émulateur de terminal équivalent, et tapez :
    $ xhost + grossebecane.distante.fr
    $ telnet grossebecane.distante.fr
    
  • après vous être connecté, tapez :
    grossebecane:$ DISPLAY=boite.linux.locale:0.0
    grossebecane:$ nomdeprogramme &
    
    ( au lieu de DISPLAY..., vous pourriez avoir à écrire setenv DISPLAY boite.linux.locale:0.0. Cela dépend du shell distant. )

Et voila! Maintenant, nomdeprogramme va démarrer sur grossebecane.distante.fr et s'affichera sur votre écran. Toutefois, n'essayez pas ceci sur une liaison PPP, celle-ci serait trop lente pour être vraiment utilisable.


Page suivante Page précédente Table des matières