Andesi - logiciels:bases-d-unix

Vous êtes ici: accueil » logiciels » bases-d-unix
Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Quelques bases d'Unix ======
===== Les terminaux =====
==== Présentation ====
Un terminal est une interface physique entre l'utilisateur et la machine, i.e.:
  * une zone d'affichage graphique (l'écran, une fenêtre X window)
  * une zone de saisie (le clavier)
Le type de terminal déclaré par la variable d'environnement TERM, permet au système de connaitre les capacités de cette interface, par exemple:
  * le nombre de lignes
  * le nombre de colonnes
  * la possibilité d'afficher du texte en gras, en couleur
  * la largeur des tabulations
  * le clignotement du curseur
  * les actions des caractères de contrôle
  * ...
Ce sont des données assez bas niveau (proche des contraintes physiques du matériel) liées au contexte historique du terminal.\\
Au début de l'utilisation des ordinateurs sous Unix, les utilisateurs se connectaient (a l'aide de machines n'ayant qu'un clavier et un écran, donc peu  chères) à des machines puissantes  qui réalisaient les calculs et traitements (puissantes, mais chères) . Il fallait que le gros système (le serveur) sache envoyer les informations en tenant compte des contraintes physiques de l'interface du client de destination pour obtenir un affichage correct des résultats de traitement.\\ 
Aujourd'hui, on se connecte toujours selon ce principe du client-serveur, et on utilise toujours des terminaux, que l'on se connecte directement sur la machine (en console), ou par le serveur X, la différence tient au fait que le serveur et le client sont sur la même machine.
//Dans la suite de cet article, nous utiliserons indifféremment, le terme console ou terminal pour désigner un terminal //
==== Obtenir un terminal ====
Il y a plusieurs façons d'obtenir un terminal sur une machine fonctionnant sous Debian GNU/Linux.\\ 
   * Au démarrage, le système lance par défaut six consoles texte (donc six terminaux).\\ Sur ces consoles en mode texte (ctrl-alt-F1 à F6), le programme du terminal //(getty)// lance le programme //login// qui attend qu'un utilisateur s'identifie auprès du système pour pouvoir l'utiliser (qu'il se loggue).
   * Si le serveur X  (programme gérant l'interface graphique utilisée,  entre autre,   par GNOME et KDE) est installé et qu'un Display Manager est activé (//xdm, gdm, kdm//), le système lance le display manager **en plus** des six consoles.\\ 
   * Dans une session X, (GNOME ou autres), on peut lancer un programme d'émulation de terminal (// xterm, gnome-terminal ou konsole//), qui démarre  alors un terminal dans une fenêtre.
==== Basculer d'un terminal dans un autre ====
Vous pouvez a tout moment basculer d'un terminal vers un autre. Cela vous permet par exemple de lancer un traitement sur le premier terminal puis de basculer dans un second en attendant que le premier ait fini sa tache et vous rende la main.
  * Pour passer du serveur X à l'un des six terminaux,  on utilise les combinaisons de touche //ctrl-alt-F1 à ctrl-alt-F6//
  * Pour revenir au serveur X depuis un terminal on utilise ctrl-alt-F7.
<note>Si on décidait de n'avoir que trois consoles au démarrage du système (c'est possible), ces consoles seraient accessibles avec ctrl-alt-F1 jusqu'à F3, et le serveur X avec ctrl-alt-F4, l'affichage du serveur X se plaçant après les consoles dans l'ordre croissant des touches </note>
<note tuyau> L'appui sur la touche //**ctrl**// dans la combianison de touches ne sert que pour passer du serveur X vers les consoles.
Quand on est déjà  sur une console on peut simplement faire **//alt-Fn//** pour changer. En effet, le serveur X "comprend" et intercepte les combinaisons avec //**alt**// (sans **//ctrl//**)  empêchant ainsi le changement de console, par contre les combinaisons avec **//ctrl//** et **//alt//** ne sont pas interceptées par le serveurX.
</note>
Le système "voit" (perçoit, interprète...) les terminaux comme des périphériques distants, reliès à la machine par des câbles (même si tel n'est pas le cas). Comme pour tout périphérique, sous Unix a un terminal correspond un fichier de périphérique dans /dev  (''/dev/tty1'' ''/dev/tty2'' etc...)
Ceci est important car les commandes donnant des informations sur les terminaux utilisent  le fichier /dev du périphérique comme identifiant du terminal. Donc, même s'il n'y a pas de ligne physique, le périphérique demeure.
<note>
Sous Unix, le matériel est représenté par des fichiers. Les programmes accèdent donc à des périphériques avec les mêmes moyen que les fichiers normaux. C'est le noyau qui fait la traduction entre l'action du programme sur le fichier périphérique et le périphérique lui-même.
</note>
Lorsqu'on se trouve sur la console correspondant à ctrl-alt-F1, on voit par exemple :
  Debian GNU/Linux Lenny/Sid tty1
sur la ligne de login, il s'agit de la ligne de terminal reliée à ''/dev/tty1'', si on passe sur la deuxième console avec ctrl-alt-F2, c'est ''...tty2'' qui est inscrit sur l'écran, on utilise désormais le terminal attaché à la ligne représentée par ''/dev/tty2''.
Pour les utilisateurs du serveur X, c'est l'émulateur de terminal qui lance le terminal sur un fichier périphérique ''/dev/pts''.
Sous X, comme l'utilisateur est déjà loggué (identifié) par sa session graphique, le programme terminal lance directement l'interpréteur de commandes, le shell (c'est le but du terminal : obtenir un shell).
La commande ''**who**'' donne un bon aperçu de cela
<code>
fred@frederic:~$ who
fred     tty1        2007-09-29 00:03
fred     :0           2007-09-27 12:24
fred     pts/0     2007-09-28 23:55 (:0.0)
</code>
On voit ici que l'utilisateur **fred** a une session (console) ouverte sur ''/dev/tty1'' et une autre (graphique) sur le ''/dev/pts0''
===== Les bases de la ligne de commande =====
Nous allons voir maintenant comment accéder à la ligne de commande, pour apprendre à utiliser le système en mode texte.
==== Entrer dans le shell : le login ====
Unix est multi-utilisateurs, c'est-à-dire que plusieurs utilisateurs peuvent ,indépendamment les uns des autres, lancer des programmes sur la machine en même temps. \\
Ceci implique que le système doit savoir : 
  * reconnaitre un utilisateur pour lui permettre de lancer des programmes. 
  * à qui appartient un programme en cours d'exécution, pour permettre aux utilisateurs de contrôler leurs programmes sans gêner les autres.
C'est pourquoi il faut s'identifier auprès du système pour l'utiliser. On entre donc son login puis son mot de passe, soit dans une console texte, soit dans un display manager si on utilise le serveur X.\\ 
Toutes les actions qu'on effectue ensuite constituent la session, qui prend fin quand on se déloggue.
<note tuyau>On peut lancer une session X en étant déja loggué dans une console, dans ce cas pas besoin de se logguer auprès de X qui reprend l'identité de la console</note>
Imaginons que Jean-Claude Dusse de Paris (qui est sous Debian depuis que Potato est sortie, et c'est pas récent ;-) ) veuille se logguer sur une console en mode texte, il entre donc son nom d'utilisateur au prompt "login:" :
<code>Debian GNU/Linux 3.1 jc.splendid.org tty1 jc.splendid.org login: jean-claude
Password:  (ici rien ne s'affiche et c'est normal)
Last login: Sun Sep 25 12:33:30 2005 on pts/3 Linux jc.splendid.org 2.6.12.4-gr1 
#1 Fri Aug 12 15:36:12 CEST 2005 i686 GNU/Linux 
Bonjour, je suis le "message of the day" (/etc/motd) 
You have mail. jean-claude@jc jean-claude $ "
</code>
Jean-Claude a bien entré son mot de passe, mais aucun echo n'est renvoyé à l'écran par soucis de sécurité : en n'affichant rien, personne d'autre que Jean-Claude ne peut savoir la longueur du mot de passe.
S'il y un problème à ce niveau, le système le signale et revient au prompt du login. 
Si l'identification est correcte, le système :
  * Affiche la date, l'heure et le terminal du dernier login de Jean-Claude
  * Affiche le message du jour, contenu dans /var/run/motd
  * Lance le shell et Jean-Claude obtient un prompt pour entrer ses commandes.
<note>Jean-Claude utilise le terminal correspondant à ctrl-alt-F1, qui se trouve connecté à la ligne tty1 (on peut facilement déduire que ctrl-alt-F2 correspond à tty2 et ainsi de suite)</note>
Maintenant, imaginons que Brigitte (c'est sa copine de fac... il n'a pas encore conclu ;-) ) veuille utiliser la machine pendant que Jean-Claude est parti aux toilettes avec son livre de mots croisés (ou de Sudoku c'est selon l'humeur !).\\
Brigitte change de console (avec ctrl-alt-f3 par exemple), elle obtient a son tour un terminal avec un prompt "login:" et se loggue.\\
Brigitte n'interfèrera pas dans les programmes de Jean-Claude, parce qu'elle utilise un terminal différent qui n'a aucun lien avec celui de Jean-Claude.\\
De plus, ils utilisent des comptes utilisateurs différents et les programmes qu'ils lancent leur appartiennent, le système le sait et peut donc gérer les droits de chacun pour éviter les conflits.
==== Saisir des commandes ====
A partir de maintenant, on utilisera principalement la console. 
  * Si vous n'utilisez pas le serveur X, il suffit de vous logguer au prompt "login:" (en prenant une autre console alt-F[1-6], histoire de continuer de lire cet article).\\
  * Si vous utilisez X, vous pouvez soit passez sur un terminal en mode texte (ctrl+alt+F1) ou lancer un terminal X comme xterm, aterm, gnome-terminal, konsole, rxvt, eterm... pour pouvoir entrer des commandes en mode texte.
Une fois le login réussi, on est dans le shell.
Le shell ou interpréteur de commande est le programme qui permet à l'utilisateur de dialoguer avec le système, c'est à dire d'ordonner au système d'exécuter des programmes. \\
Pour cela, le shell attend que l'utilisateur entre des instructions au clavier, instructions qu'il exécutera quand l'utilisateur validera sa commande.
==== En Pratique ====
Pour taper une commande, entrez le texte au clavier et terminez par la touche [entrée] pour valider, la commande s'exécute et lorsque c'est terminé, le prompt revient (la ligne finissant par $), on peut ensuite entrer d'autres commandes et ainsi de suite.
Une commande est une instruction donnée au shell, l'utilisateur écrit le nom d'un programme avec (ou sans) options pour ce programme. Il valide avec [entrée].\\
A ce moment le shell lance le programme et se remet en attente de commande quand l'exécution est terminée.\\
Devant le curseur, le shell affiche un texte terminé par un dollar $, il s'agit du prompt qui permet à l'utilisateur de savoir si le shell est disponible pour recevoir une commande ou si un programme lancé est toujours en cours d'exécution.
Pour illustrer ceci, voyons l'exemple de la commande "passwd" qui permet de changer son mot de passe :
<code>
fred@frederic:~$ passwd                      
                                             --> Nous sommes ici dans le shell
Changing password for fred.
Mot de passe UNIX (actuel) :
                                            --> Nous sommes dans le programme passwd, il attend notre MdP actuel
Entrez le nouveau mot de passe UNIX :        
                                            --> Toujours dans le programme passwd, il attend notre nouveau MdP
Retapez le nouveau mot de passe UNIX :
                                            --> Toujours dans le programme passwd, il attend confirmation du MdP
passwd : le mot de passe a été mis à jour avec succès
fred@frederic:~$                             
                                           --> Retour au shell, on peut saisir une autre commande
</code>
Dans de nombreux cas il faudra donner  aux programmes  à lancer des paramètres (ou arguments). \\ 
Ces arguments sont placés à la suite du nom du programme et séparés par un blanc, c'est-à-dire un ou plusieurs espaces. L'espace a donc une signification spéciale pour le shell : il sépare les éléments d'une commande.\\ 
Voici une exemple de commande demandant de lister le contenu du fichier /home/toto . 
<code>$ls /home/toto
Desktop                     mp3
Download                    ogg
FicheMateriel.pdf           PDF
FichesMateriel.pdf          Planning
FusionPDF                   Prive
Professionnel
</code>
**ls** est la commande, **/home/toto** l'argument
Les options qui modifient le comportement d'un programme sont différenciées dans autres paramètres par le fait qu'elles commencent par un tiret (-) et qu'il s'agit de chiffres ou de lettres, par exemple -a -x. \\
Voici par exemple la même commande que ci dessus mais complétée des options -l et -a (soit -la) permettant d'obtenir une sortie plus détaillée
<code>$ls -la /home/toto
drwxr-xr-x 64 fred fred   4096 2007-10-08 16:44 .
drwxr-xr-x  5 root root   4096 2007-08-22 11:54 ..
drwxr-xr-x  3 fred fred   4096 2007-08-22 16:28 .adobe
drwxr-xr-x 10 fred fred   4096 2007-09-24 08:31 .amsn
drwx------  2 fred fred   4096 2007-09-28 14:10 amsn_received
-rw-------  1 fred fred   7125 2007-10-08 18:05 .bash_history
-rw-r--r--  1 fred fred    220 2007-08-21 10:59 .bash_logout
-rw-r--r--  1 fred fred    414 2007-08-21 10:59 .bash_profile
-rw-r--r--  1 fred fred    118 2006-09-08 08:23 .bashrc
drwxr-xr-x  5 fred fred   4096 2007-08-21 13:35 .cache
</code>
Le système GNU introduit, par rapport aux autres systèmes Unix, des options avec des noms longs commençant par deux tirets et constitués d'un nom entier (--target), le nom d'une option longue peut être sur plusieurs mots séparés par des tirets.\\
Par exemple
<code >#apt-get install --reinstall wajig</code>
Pour séparer deux commandes, on utilise le point-virgule (;), qui permet donc d'entrer plusieurs commandes sur une même ligne, les commandes seront exécutées à la suite, dans l'ordre de gauche à droite.
Pour entrer une commande sur plusieurs lignes sans valider, on place un anti-slash (\) à la fin de ligne pour la couper, puis on peut taper sur  //entrée //  pour aller à la ligne et continuer la saisie.
==== Sortir du shell : le logout ====
Pour terminer la session, on entre la commande exit, on peut aussi faire ctrl-d
===== Les utilisateurs et groupes =====
==== Informations sur les utilisateurs ====
Pour savoir sous quel utilisateur vous êtes loggué, utilisez la commande whoami (qui suis-je ?) qui affiche votre nom d'utilisateur.
<code> whoami
freddec
</code>
Il existe aussi la commande id, qui permet de connnaître votre uid, c'est à dire le numéro correspondant à voter login (le système utilise l'uid dans son fonctionnement interne) et la liste des des groupes dont vous faites partie. id donne les noms correspondant à ces id.
<code>id
uid=1000(fred) gid=1000(fred) groupes=0(root),4(adm),20(dialout),24(cdrom),
25(floppy),29(audio),44(video),46(plugdev),106(netdev),110(powerdev),1000(fred)
</code>
Pour connaitre la liste des utilisateurs loggués à cet instant sur le système, utilisez la commande who, elle affiche la liste des utilisateurs loggué avec des informations supplémentaires (ligne du terminal, date et heure de login)
<code>~$ who
fred     :0           2007-10-05 08:31
fred     pts/0        2007-10-08 18:20 (:0.0)
</code>
==== Les groupes ====
Les groupes permettent de rassembler des utilisateurs essentiellement pour leur donner des droits d'accès. Il est effectivement plus aisé de gérer des utilisateurs avec profils communs avec des groupes lorsqu'on a beaucoup d'utilisateurs.
Tout utilisateur possède un groupe principal. Il peut aussi être membres de groupes supplémentaires en fonction de son utilisation du système. Par exemple, sous Debian, il faut être membre du groupe audio pour modifier le volume du son.
==== Changer le mot de passe ====
Pour changer de mot de passe on utilise passwd. Lancé tel quel, il permet de changer le mot de passe pour l'utilisateur courant, si on spécifiez un login après, vous changerez le mot de passe de cet utilisateur.
==== Changer d'utilisateur ====
Vous pouvez changer d'utilisateur en prenant une autre console et vous logguant avec un compte différent. Vous pouvez aussi utiliser la commande su qui permet de changer d'utilisateur dans la même session :
<code>
jc $ su brigitte 
Password: 
brigitte $ "
</code>
Lorsque vous n'avez plus besoin d'être cet utilisateur, il suffit de taper exit pour sortir du shell lancé par su pour revenir dans son shell d'origine, vous aviez lancé une deuxième session dans la première grâce à su.
===== Les Commandes du Shell et l'aide en ligne=====
Lorsque vous ignorez à quoi sert telle ou telle commande, ou quelle peut bien être sa syntaxe, ses options, Gnu/Linux Debian est là pour vous fournir la réponse.
==== Aides des commandes (Help)====
Il vous suffit de saisir dans la console "help" suivit du nom de la commande pour obtenir un bref descriptif de son rôle
<code> help cd
cd: cd [-L|-P] [dir]
     Change the current directory to DIR.  The variable $HOME is the
    default DIR.  The variable CDPATH defines the search path for
    the directory containing DIR.  Alternative directory names in CDPATH
    are separated by a colon (:).  A null directory name is the same as
    the current directory, i.e. `.'.  If DIR begins with a slash (/),
    then CDPATH is not used.  If the directory is not found, and the
    shell option `cdable_vars' is set, then try the word as a variable
    name.  If that variable has a value, then cd to the value of that
    variable.  The -P option says to use the physical directory structure
    instead of following symbolic links; the -L option forces symbolic links
    to be followed.
</code>
==== Les pages de manuel (man)====
Pour obtenir des informations plus précise, syntaxe, option etc... la commande **man** est là qui vous fournit tout ce dont vous avez besoin de savoir (ou presque)
<code>CHMOD(1)                         User Commands                        CHMOD(1)
NAME
       chmod - change file access permissions
SYNOPSIS
       chmod [OPTION]... MODE[,MODE]... FILE...
       chmod [OPTION]... OCTAL-MODE FILE...
       chmod [OPTION]... --reference=RFILE FILE...
DESCRIPTION
       This manual page documents the GNU version of chmod.  chmod changes the
       permissions of each given file according to mode, which can be either a
       symbolic  representation  of changes to make, or an octal number repre‐
       senting the bit pattern for the new permissions.
       The   format   of   a   symbolic   mode   is    ‘[ugoa...][[+-=][rwxXs‐
       tugo...]...][,...]’.   Multiple symbolic operations can be given, sepa‐
       rated by commas.
.../...
</code>
==== GNU info ====
FIXME
===== Plus loin avec le shell =====
==== Complétion avec TAB ====
Quoi de plus énervant que de saisir de longues ligne de code au clavier , avec les risques d'erreur de frappe que cela implique ? :-(  \\
Heureusement encore une fois le shell est là pour vous aider grace a l'autocomplètion de la touche **TAB** :-) \\
Saisissez les premières lettres d'une commande (**chm** par exemple) puis pressez la touche de tabulation, et hop voila la suite de la commande terminée automatiquement (**chmod**).\\
Il ne se passe rien ? C'est que plusieurs commandes ont le même début, pressez de nouveau la touche **TAB**  et le shell vous donne la liste de toutes les commandes commençant par les caractères que vous avez saisis.
<code>ch
chage      charset    chcat      chfn       chkdupexe  chown      chvt
charmap    chattr     chcon      chgrp      chmod      chsh       
</code>
Cela fonctionne également pour les chemins d'accès, saisissez les premières lettres du répertoire ou du fichier désiré, puis **TAB** et la ligne se complète. Une seconde pression vous donne également la liste des fichiers et répertoires se trouvant directement sous le point où vous trouvez dans la ligne de commande
==== Historique des commandes ====
Le shell vous évite également la re-saisie fastidieuse des commandes que vous venez déjà de saisir.\\
Une pression sur la touche <Flèche Haute> rappel la dernière commande saisie, et ainsi de suite pour chaque pression supplémentaire
Qui a dit que la machine a remonter le temps n'existait pas ? Si Si, elle tourne sous Linux !  :-o 
==== Variables d'environnement ====
==== Aliases ====
===== Les processus =====
==== Définition ====
==== Entrées sorties ====
==== Le shell et les processus ====
=== Redirections ===
=== Jobs ===
logiciels/bases-d-unix.txt · Dernière modification: 22/05/2010 18:14 par orgrim