Lea Linux - Contributions [fr]

Tenir compte de la sécurité au quotidien

2006-06-26T17:28:08Z

Basile S (phorum) :

D'abord et avant tout il faut être à l'aise avec les concepts essentiels de [http://fr.wikipedia.org/wiki/Linux linux]. Donc documentez vous sur ce système et son langage de commande.

Ensuite, veillez à ne pas démarrer des services inutiles.

Glibc

2006-04-21T10:10:46Z

Basile S (phorum) : /* Plus d'infos sur cette partie (plugins) */

[[Category:Développer sous Linux]]
= Les Librairies C (linux) =

<div class="leatitre">Les Librairies C (linux)</div><div class="leapar">par [mailto:xgarreau@club-internet.fr Xavier GARREAU (alaide)]</div><div class="leadesc">Dans cette page, je vais évoquer la rédaction, la compilation et l'utilisation des librairies en C. Je traiterai avant tout de développement sous linux bien que la majorité des explications soient applicables à d'autres systèmes d'exploitation, y compris ceux qu'on voudrait voir passer par la fenêtre ;-).</div>
----

== Introduction ==

=== Intérêt ? ===

Imaginez : Vous avez développé une série de fonctions très utiles pour un projet, prenons l'exemple d'un tri par bulles. Un jour, vous devez effectuer une nouvelle série de tris. Vous ouvrez le projet et passez la journée à faire du copier coller ?!?! '''''NON !!!''''' car vous aviez pensé à créer un librairie contenant la fonction principale du tri, n'est ce pas ? <br /> Les librairies permettent de se constituer des bibliothèques de fonctions réutilisables et distribuables.

Vous voulez un autre avantage des librairies ?<br /> On les compile à part ! Si vous avez comme moi un pc qui se fait vieux, vous savez que la compilation peut prendre pas mal de temps. La bonne nouvelle c'est qu'une fois les librairies compilées, vous ne les recompilez pas à chaque fois que vous recompilez votre projet. Tout au plus, vous les liez, s'il s'agit de bibliothèques statiques.

=== Qu'est ce qu'il y a dedans ? ===

Une librairie est composée d'un fichier d'en têtes (headers en anglais, d'ou le .h), ce sont les fichiers .h qui doivent vous dire quelque chose, non ? Et d'un partie binaire. <br /> Le fichier d'en têtes, permet de "déclarer" les fonctions présentes dans la librairie, le type de valeurs qu'elles renvoient et les paramètres à leur passer. <br /> La partie binaire est constituée d'un ou plusieurs fichiers c compilés. Ces fichiers c contiennent l'implémentation des prototypes de fonctions déclarées dans le fichier d'en têtes. <br /> Vous pouvez modifier le code de la librarie autant que vous le désirez, du moment que vous respectez les prototypes définis dans le fichier .h.

=== Statique, Dynamique ? ===

Ouais, entrons dans le vif du sujet. Qu'est ce qu'une librairie statique ? et une librairie dynamique ? Quelles sont les avantages et inconvénients de chacune ?

* Quand vous utilisez une librairie statique (généralement .a sous linux, .lib sous ouinouin) la librairie est ''liée'' à l'exécutable généré. C'est à dire que vous obtenez un fichier exécutable relativement "lourd". <br />'''D'autre part''', si vous apportez des modifications à la librairie, vous devez recompiler la librairie '''ET''' l'exécutable. <br />'''Bon coté''' : lorsque vous distribuez votre application, l'exécutable contient tout ce qui lui est nécessaire pour fonctionner, ce qui évite les problèmes de dépendances.
* L'utilisation des librairies dynamiques apporte plusieurs avantages :
*# La librairie est liée au programme qui l'utilise lors de l'exécution, l'exécutable distribué est ainsi plus léger que dans le cas d'une librairie statique.
*# La librarie n'est chargée qu'une fois en mémoire, même si elle est utilisée par plusieurs exécutables.
*# Lors de modifications apportées à la librarie, l'application l'utilisant n'a pas besoin d'être recompilée, à la condition toutefois que ces changements respectent les prototypes définis dans le fichier d'en têtes.
<br />Mais il y a aussi des inconvénients :
*# Pour exécuter une application faisant appel à une librarie dynamique, vous devez posséder ces librairies et elles doivent pouvoir être trouver par le système. Nous verrons plus loin quelques façons de vérifier tout celà.
*# Le temps de lancement peut être plus long, étant donné que la liaison se fait lors de l'exécution.
<br />'''Nota Bene''' : les liens avec les librairies dynamiques ne se font pas toujours lors de l'exécution, un programme peut en effet charger lui même les librairies dont il a besoin quand il en a besoin (voir les fonctions dlopen() et dlsym()), Celà est utile pour construire l'application au fur et à mesure de son exécution. Imaginez par exemple que vous écriviez un programme de retouche d'image, pourquoi charger les libraries de traitement de fichier jpeg si pendant une "''session''" l'utilisateur ne se sert que de fichiers .png ?

=== Plus d'infos sur cette partie ? ===

Consultez les pages man de dlopen et dlsym et celles qui y sont conseillées et tapant dans la console

<blockquote>

man dlopen
man dlsym

</blockquote>

Ces fonctions permettent notamment de réaliser des "plugins", c'est à dire des bout de codes qui sont chargés durant l'exécution, pour permettre par exemple d'étendre les fonctionalités d'un programme sans le modifier (à condition que ça été prévu). En pratique, un programme peut charger par dlopen beaucoup (des milliers au moins) de "plugins" ensemble.

Une autre possibilité est même de méta-programmer, c'est à dire d'écrire un programme qui génère le code pour le traitement approprié des données. Il suffit pour ça (par exemple) de générer à l'exécution du code C dans un fichier ''gen.c'', de lancer depuis le programme sa compilation (avec la fonction ''system'' du C par exemple) en exécutant la commande
<code>gcc -O -fPIC -shared gen.c -o gen.so</code>, puis de charger le code obtenu par ''dlopen''

== Rédaction : remarques ==

=== Quelques généralités ===

Si vous voulez que votre librairie soit réutilisable et efficace, vous devez respecter quelques notions fondamentales de la programmation.

* Limitez au minimum les variables globales. Préférez, lorsque c'est possible, de passer des paramètres au fonctions plutôt que d'utiliser les variables globales. C'est plus facile de s'y retrouver et ça occuppe moins de mémoire. <br />'''Par exemple''', si vous avez une fonction qui traite les données d'un tableau dont vous devez connaitre le nombre d'éléments : <blockquote>
{| width="60%" bgcolor="#fcd8d8"
| align="center" | '''Pas Bien !'''
|-
| Cette solution fait appel à une variable globale pour connaitre la taille du tableau. C'est déconseillé !
|-
| bgcolor="#fcfcd8" |
/*
* ...
*/
int tailleTab;
long * traiteTab (long * tab) {
/*
*
* Traitement des données
*
*/
}
/*
* ...
*/
|}
<br />
{| width="60%" bgcolor="#fcd8d8"
| align="center" | '''Bien !'''
|-
| Ici, la taille du tableau est passée en paramètre à la fonction. C'est mieux !
|-
| bgcolor="#fcfcd8" |
/*
* ...
*/
long * traiteTab (long * tab, int tailleTab) {
/*
*
* Traitement des données
*
*/
}
/*
* ...
*/
|}
</blockquote>
* Commentez vos sources ! Comment voulez vous vous y retrouver rapidement dans le code de quelqu'un d'autre ou même le vôtre si il n'y a aucun commentaire ? Celà est surtout vrai pour les fichiers d'en tête, expliquez ce que font les fonctions et ce que sont les arguments. (Je sais, c'est moins chiant à dire qu'à faire)
* Evitez le plus possible les structures spécifiques à une application particulière. Par exemple, si vous utilisez des chaines de moins de 50 caractères dans votre application, ne limitez pas vos variables à cette valeur. Qui sait si votre patron ne va pas décider dans deux jours que les chaînes doivent pouvoir comporter 1000 caractères ? (Je vous jure que ça arrive ! ;-) ). Préférez toujours, quand c'est possible, une allocation dynamique de mémoire à vos variables. (voir malloc(), realloc(); calloc() et free())
* Lorsqu'on utilise des fichiers d'en têtes abondamment, il y a un risque d'en inclure un plusieurs fois, ce qui allonge le temps de compilation et produit éventuellement des erreurs. pour pallier à ce problème, on utilise la clause #ifndef __NOM_FICHIER_H. <br />'''Par exemple''', si votre fichier s'appelle monTest.h, placez ceslignes au début et à la fin du fichier: <blockquote>
{|
| bgcolor="#fcd8d8" | Si le fichier à été inclus, _MON_TEST_H est défini et il ne le sera pas à nouveau.
|-
| bgcolor="#fcfcd8" |
<nowiki>
#ifndef _MON_TEST_H
#define _MON_TEST_H 1
/*
* ...
*ici, le contenu normal du fichier monTest.h
* ...
*/
#endif
</nowiki>
|}
</blockquote>

=== Les "chemins" ===

'''La directive <code><nowiki>#include</nowiki></code>''' : pour inclure un fichier dans un autre en c, on utilise la directive <code><nowiki>#include</nowiki></code>. <br />On spécifie le chemin relatif entre le fichier incluant et le fichier inclus, par exemple : <br /><code><nowiki>#include "mesH/monTest.h"</nowiki></code><br />ou bien on place le fichier .h dans le répertoire ou le compilateur s'attend à trouver les fichiers .h. (regardez dans /usr/include par exemple) et on donne le chemin relatif par rapport à ce répertoire, par exemple : <br /><code><nowiki>#include <orb/orbit.h></nowiki></code><br />'''Nota Bene''' : On peut également spécifier d'autres chemins de recherche grâce à l'option -I de gcc, par exemple, pour y inclure le répertoire courant : <br /><code>gcc -I. etc...</code>

Pour devenir incollables sur ces amusantes petites choses, apprenez par coeur les man pages de gcc et ld. ;-)

=== Plus d'infos sur cette partie ? ===

Consultez les pages man des fonctions d'allocation dynamique de mémoire, du compilateur, du linker et celles qui y sont conseillées et tapant dans la console :

<blockquote>

man malloc
man realloc
man calloc
man free
man gcc
man ld

</blockquote>

On rentre enfin dans le vif du sujet avec cette partie. On va en effet maintenant suivre un exemple pas à pas pour construire une librarie, la compiler, l'utiliser dans un exécutable sous ses formes statiques et dynamiques. <br /> On va prendre l'exemple d'un librairie comportant une fonction permettant de trier un tableau contenant des entiers longs. La méthode de tri sera le tri par bulles. Je ne suis pas vraiment sûr que ce soit cet algorithme là mais ça marche alors ... Roule !

----

<br />

== Rédaction : le fichier d'en têtes ==

Bien entrons dans le dedans du vif du sujet ! ouvrez un éditeur de texte et tapez ça dans un fichier tri_a_bulles.h :

<blockquote>

{| bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" | '''tri_a_bulles.h'''
|-
|
<nowiki>
/*
* tri_a_bulles.h
*
* Quelques fonctions pour opérations basiques sur un tableau de longs.
*
* auteur: Xavier GARREAU : xgarreau@club-internet.fr
*
* web : http://perso.club-internet.fr/xgarreau/
*
* dmodif: 13.03.2000
*
*/
#ifndef _TRI_A_BULLES_H
#define _TRI_A_BULLES_H 1

/*
* test_case_tableau : Dans le tableau pointé par addr_tableau,
* Vérifie que la case case case_tableau est bien placée par rapport à celle qui la précède
* Si ce n'est pas le cas, permute les cases et se rappelle sur la case précédente.
* La récurrence s'arrête quand
* la case case case_tableau est bien placée par rapport à celle qui la précède
* ou bien si case_tableau vaut prem_case_tableau.
* Ne renvoie rien.
*
*/
void test_case_tableau ( long * addr_tableau,
int taille_tableau,
int case_tableau,
int prem_case_tableau );

/*
* permut_cases :
* permute les valeurs des cases case_1 et case_2 du tableau pointé par addr_tableau
* Ne renvoie rien.
*
*/
void permut_cases ( long * addr_tableau,
int case_1,
int case_2 );

/*
* test_tableau :
* renvoie le tableau pointé par addr_tableau trié (ordre croissant)
* de la case prem_case_tableau
* à la case taille_tableau-1
*
*/
long * test_tableau ( long * addr_tableau,
int prem_case_tableau,
int taille_tableau );

/*
* nb_cases_tableau :
* Renvoie le nombre de cases du tableau pointé par addr_tableau
* càd nombre de cases allouées
* ou première case contenant (long)NULL si le tableau en contient une.
*
*/
int nb_cases_tableau ( long * addr_tableau );

#endif
</nowiki>
|}

</blockquote>

Si vous êtes familier avec les fichiers .h, pas de problème. Sinon, disons qu'on se contente de définir les "prototypes" des fonctions, on écrira leur corps dans un fichier .c. <br />Les fichiers .h permettent au compilateur de connaitre les prototypes des fonctions qu'il rencontre dans les différents fichiers.c qui les utilisent.

'''Je m'explique !''' Les fonctions définies dans un fichier .c peuvent être utilisées dans un autre, ça vous le savez ! (hein ? vous le savez ?) Il suffit de préciser au compilateur tous les fichiers à compiler (<code>gcc fic1.c fic2.c ... ficn.c</code>). Si par hasard vous commettez une erreur en appelant une fonction, vous verrez que la compilation se passera sans problème, '''MAIS''', lors de l'exécution vous obtiendrez des résultats inattendus ou pire, une erreur. Brrrrrrrrrrrr ... Flippant non ?

Bon, si on programmait ? Un petit peu de récursivité maintenant ? '''''GO ! BANZAI !'''''

== Rédaction : le fichier c ==

Ouvrez un éditeur de texte et tapez ça dans un fichier tri_a_bulles.c :

<blockquote>

{| bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" | '''tri_a_bulles.c'''
|-
|
<nowiki>
/*
* tri_a_bulles.c
*
* Quelques fonctions pour opérations basiques sur un tableau de longs.
*
* auteur: Xavier GARREAU : xgarreau@club-internet.fr
*
* web : http://perso.club-internet.fr/xgarreau/
*
* dmodif: 13.03.2000
*
*/
#include "tri_a_bulles.h"

void test_case_tableau ( long * addr_tableau,
int taille_tableau,
int case_tableau,
int prem_case_tableau ) {
if ( case_tableau > prem_case_tableau )
if (addr_tableau[case_tableau] < addr_tableau[case_tableau-1]) {
permut_cases ( addr_tableau,
case_tableau,
case_tableau-1 );
test_case_tableau ( addr_tableau,
taille_tableau,
case_tableau-1,
prem_case_tableau );
}
}

void permut_cases ( long * addr_tableau,
int case_1,
int case_2 ) {
long tempo;

tempo = addr_tableau[case_1];
addr_tableau[case_1] = addr_tableau[case_2];
addr_tableau[case_2] = tempo;
}

long * test_tableau ( long * addr_tableau,
int prem_case_tableau,
int taille_tableau ) {
int i;

for (i=prem_case_tableau ; i<taille_tableau ; i++)
test_case_tableau (addr_tableau,
taille_tableau,
i,
prem_case_tableau);

return addr_tableau;
}

int nb_cases_tableau ( long * addr_tableau ) {
int nb_cases;

nb_cases=0;
while (addr_tableau[nb_cases]) nb_cases++;
return (nb_cases);
}
</nowiki>
|}

</blockquote>

Finalement ça s'est bien passé non ? Pas si compliqué ! <br />Bon si on veut utiliser ça il va falloir créer une application qui en a besoin ! On y va ?

== Rédaction : le fichier de l'application ==

Maintenant que nous avons les sources de notre librairie, prêtes à être compilées et liées, il va falloir penser à construire une application pour utiliser les fonctions que l'on y a mis ! Ce sera bientôt chose faite si vous voulez bien vous prêter encore un peu au jeu de cette dernière fastidieuse saisie.

Ouvrez un éditeur de texte et tapez ça dans un fichier test.c :

<blockquote>

{| bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" | '''test.c'''
|-
|
<nowiki>
/*
* test.c
*
* Une application qui utilise les fonctions de la librairie tri_a_bulles
*
* auteur: Xavier GARREAU : xgarreau@club-internet.fr
*
* web : http://perso.club-internet.fr/xgarreau/
*
* dmodif: 14.03.2000
*
*/
#include <stdio.h>
#include <stdlib.h>
#include "tri_a_bulles.h"

int main (int argc, char * argv[]) {
long * tab;
int i;

/* créée un tableau de 10 longs */
tab = (long *)malloc( 10 * sizeof (long) );

/* Initialise le générateur de nombre aléatoires avec ...
* L'heure de lancement ...
* voir man random ou man rand pour le pourquoi de la chose !!!
* voir man time pour le comment !!!
*/
srandom((int)time((time_t *)NULL));

/* remplit le tableau avec une suite de nombres pseudo-aléatoires
* et affiche le contenu.
*/
for (i=0; i<10; i++) {
tab[i] = random();
printf ("tableau[%d] = %ld\n", i, tab[i]);
}

/* Affiche le nombre de cases su tableau retourné par la librairie */
printf ("\nTaille du tableau : %d\n", nb_cases_tableau (tab));

/* Permute 2 cases et affiche le tableau résultant */
permut_cases (tab, 2, 8);
printf ("\nTableau après permutation des cases 2 et 8.\n");
for (i=0; i<10; i++)
printf ("tableau[%d] = %ld\n", i, tab[i]);

/* Trie le tableau et affiche le résultat */
printf ("\nTableau trié par la fonction de la librairie\n");
test_tableau ( tab, 0, nb_cases_tableau (tab) );
for (i=0; i<10; i++)
printf ("tableau[%d] = %ld\n", i, tab[i]);

return 0;
}
</nowiki>
|}

</blockquote>

Bien ! Maintenant qu'on a tous les bouts, on va pouvoir compiler, lier, exécuter, etc...

== Compilation de tous les binious ==

Bon, et bien, nous y voilà, on a tout ! Il ne nous reste plus qu'à tout mettre nesemble selon différentes méthodes. On va commencer par la méthode du projet unique, sans librairies. <br /> Après ça, on va se faire une petite librairie statique, ensuite, on va mettre en place une librarie dynamique (ou shared object, .so chez les pingouins, .dll chez les défenestrés !) <br />On n'abordera toutefois pas le cas de la construction des dll car franchement, ce serait perdre du temps pour rien. Je suis pour laisser les gens qui n'ont que ça pour occupper leurs tristes journées générer et utiliser (de façon HYPER galère) les librairies dynamiques en envirronnement ouinouin. Ici, je pense que nous sommes entre gens sérieux, on développe donc sous linux, FreeBSD, solaris ou autres unix. Franchement, je m'excuse de sembler aussi méchant vis à vis de wintruc mais quand vous aurez comparé les qualités des deux systèmes (au moins en matière de support de développement), je suis presque sûr que vous penserez comme moi.

A la fin de cette série d'infos, je vous renverrai sur les bons coins pour utiliser les makefiles, ainsi que les merveilleux outils GNU que sont autoconf, autoscan, automake et leurs copains.

<blockquote>

{| width="80%" bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" |
=== Sans librairies ===
|-
|
Placez vous dans le répertoire du projet puis tapez ça dans la console :

gcc -o test test.c tri_a_bulles.c

Ceci génère un exécutable test que l'on lance, toujours en étant placé dans le répertoire de projet, en tapant :

./test
|}

{| width="80%" bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" |
=== Avec librairies statiques ===
|
|-
|
Placez vous dans le répertoire du projet puis tapez ça dans la console :

gcc -c test.c

Vous obtenez un objet binaire test.o. C'est une compilation sans édition de liens. Compilez de même la librairie en tapant :

gcc -c tri_a_bulles.c

Ce qui donne tri_a_bulles.o. Comme je l'ai déjà dit, si plusieurs fichiers composent la bibliothèque, on aurait tapé

gcc -c fic1.c fic2.c ...

Il faut ensuite créer la bibliothèque. Pour celà, tapez :

ar -q tri_a_bulles.a tri_a_bulles.o

S'il y avait eu plusieurs fichiers ... référez vous au pages man de ar. Regardez surtout les options a, q et c !

Ok, maintenant on lie le tout :

gcc -o test test.c tri_a_bulles.a

Petite précision, normalement, l'éditeur de liens GNU de linux c'est ld. Ceci dit, ça marche avec gcc parce qu'il "l'appelle" alors, on ne vient pas se plaindre. Toutefois, dans le doute et pour en savoir plus, tapez <code>man ld</code>

On ne se laisse pas décourager pour autant et on exécute :

./test

C'est bizzare non ? Ca marche pareil. Bienvenue dans le monde du codage efficace ...
|}

{| width="80%" bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" |
=== Avec librairies dynamiques ===
|-
|
Placez vous dans le répertoire du projet puis tapez ça dans la console :

gcc -c test.c

Puis :

gcc -c tri_a_bulles.c

Jusque là, vous n'êtes pas perdus, c'est pareil ! Oui, mais, maintenant on génère la librairie dynamique :

gcc -o tri_a_bulles.so -shared tri_a_bulles.o

Puis on génère l'exécutable en lui disant qu'il fera appel à la librarie dynamique tri_a_bulles.so :

gcc -o test test.o tri_a_bulles.so

Puis content qu'on est, on exécute :

./test
./test: error in loading shared libraries:
tri_a_bulles.so:
cannot open shared object file:
No such file or directory

Et oui, le bon des librairies partagées c'est qu'elles sont liées au moment de l'exécution. Or, les librairies partagées, le système va les chercher dans un répertoire contenu dans la variable d'environnement LD_LIBRARY_PATH. Et bien, par défaut le répertoire courant n'en fait pas partie ... C'est con ? <br />'''Non''', pas tant que ça ! Et il y a des outils, là encore pour faciliter les choses ... <br />Tapez :

ldd ./test
tri_a_bulles.so => not found
libc.so.6 => /lib/libc.so.6 (0x4001a000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

Visiblement, il y a une couille ! <br /> Alors, soit vous copiez votre librairie dans les répertoires qui contiennent des librairies dynamiques (/usr/lib, /usr/i486-linux-libc5/lib ou /usr/X11R6/lib chez moi), vous trouverez ça dans le fichier '''''/etc/ld.so.conf'''''. <br />Ou alors ajouter votre répertoire à la variable en tapant <br /><code>export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH</code><br />Dans les deux cas, vous obtiendrez le résultat attendu en tapant :

./test
|}

</blockquote>

== En conclusion ==

<br />

=== Avec les libraries statiques : ===

* Vous fournissez l'interface et maintenez le binaire.
* Vous pouvez apportez les modifications (à condition de respecter l'interface) que vous voulez à la librarie MAIS :
* Toute modification de librairie nécessite une réédition de lien, d'ou recompilation de l'exécutable !

<br />

=== Avec les libraries dynamiques : ===

* Vous fournissez l'interface et maintenez le binaire.
* Vous pouvez apportez les modifications (à condition de respecter l'interface) que vous voulez à la librarie.
* En cas de modification, vous n'avez qu'à remplacer l'ancienne librairie par la nouvelle.

=== Notons que : ===

* L'option ''-o nom'' sert à préciser le nom de l'exécutable résultant, ici '''test'''. Sinon, on obtient un binaire exécutable '''a.out'''.
* L'option ''-c'' sert à compiler sans édition de liens.
* Les extensions .a et .so n'ont rien de formel. Si vous voulez, dans un élan nostalgique, utiliser .lib et .dll ou .bite et .cul, vous avez le droit, vous êtes libres, vous êtes sous linux ...
* Il est bon de taper dans sa console bien aimée : <code>man gcc</code>
* Il est bon de taper dans sa console bien aimée : <code>man ar</code>
* Il est bon de taper dans sa console bien aimée : <code>man ld</code>
* ldd sert à connaître les dépendances dynamiques d'un exécutable.
* On peut ajouter des chemins de recherche de librairies dynamiques dans la vairiable d'environnement LD_LIBRARY_PATH ou dans le fichier /etc/ld.so.conf.

=== Le résultat ===

{| width="80%" bgcolor="#fcfcd8"
| align="center" bgcolor="#fcd8d8" | '''J'allais oublier !!!'''
|-
|
Normalement, le programme affiche un truc comme ça :

xavier@Rooty
Rep: tabLong
$ ./test
tableau[0] = 1613489603
tableau[1] = 866884903
tableau[2] = 295298324
tableau[3] = 1614953842
tableau[4] = 1111079167
tableau[5] = 950260573
tableau[6] = 901366332
tableau[7] = 745370511
tableau[8] = 2063084132
tableau[9] = 374329280

Taille du tableau : 10

Tableau après permutation des cases 2 et 8.
tableau[0] = 1613489603
tableau[1] = 866884903
tableau[2] = 2063084132
tableau[3] = 1614953842
tableau[4] = 1111079167
tableau[5] = 950260573
tableau[6] = 901366332
tableau[7] = 745370511
tableau[8] = 295298324
tableau[9] = 374329280

Tableau trié par la fonction de la librairie
tableau[0] = 295298324
tableau[1] = 374329280
tableau[2] = 745370511
tableau[3] = 866884903
tableau[4] = 901366332
tableau[5] = 950260573
tableau[6] = 1111079167
tableau[7] = 1613489603
tableau[8] = 1614953842
tableau[9] = 2063084132

En scoop, vous apprenez que mon pc s'appelle Rooty (ce qui vient des ''Régulateurs'' de '''Bachman'''), que je me connecte sous le nom de xavier et que ce projet se trouve dans le répertoire tabLong. En outre le symbole '''$''' précise que je ne suis qu'un simple utilisateur, le root ayant droit à un superbe '''<nowiki>#</nowiki>'''. Voilà !
|}

Pour ce qui est du renvoi sur la doc sur autoscan, autoconf, automake et leurs copains ce que j'ai trouvé de plus sympa, ce sont les infos pages du gnome-help-browser. Si vous ne l'avez pas installé, vous pouvez les consulter dans la console en tapant <code>info automake</code> ou <code>info autoscan</code>, etc ... !

Pour trouver moults docs de developpement, voyez http://developer.gnome.org/. Il existe la même chose avec les libs kde sur http://developer.kde.org/. Il existe bien d'autres sources d'infos mais ce sont celles que je préfère.

Un petit conseil, si vous aimez le c, installez les librairies gtk+/gdk/glib/imlib/ORBit C'est le top. <br />Vous cherchez un environnement de développement ? Choisissez gIDE et glade si vous avez des affinités avec le projet et les librairies du projet gnome ou kdevelop pour affinités avec KDE. <br />Comme débogueur je dois dire que kdbg est génial, d'autant qu'il s'intègre via DCOP dans kdevelop. Mais xemacs est pas mal non plus et gdb tout seul aussi, le tout c'est de connaitre ! <br />En bref, prenons ce qui existe de meilleur partout. Bienvenue dans linux et à bientôt pour de nouvelles aventures ...

<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Xavier GARREAU (alaide) le 03/01/2001.</div>

= Copyright =
Copyright © 03/01/2001, Xavier GARREAU (alaide)
{{CC-BY-NC-SA}}

Shell

2006-03-11T07:44:56Z

Basile S (phorum) : /* Commandes pour débuter */

[[Category:Environnement système]]
= Le shell ou le retour du C:> ! (et les commandes) =

<div class="leatitre">Le shell ou le retour du C:> ! <br /> (et les commandes)</div><div class="leapar">par Jean-Christophe, [mailto:SPI.MJ%20%3Cspi.mj%20chez%20wanadoo.fr%3E Marc] et Anne</div><div class="leadesc">Le shell, un environnement écrit au temps ou les hommes étaient des hommes :-)</div>
----

== Introduction ==

Qu'est-ce que '''shell''' me direz vous ? Certains diront que c'est ça le vrai Linux. il n'y a pas que du faux là-dedans, puisque étymologiquement parlant, "Linux" est juste le nom du noyau du système d'exploitation, et qu'on a tendance par abus de langage à utiliser "Linux" pour désigner l'ensemble de Linux, du serveur X et des nombreuses applications.

Bref, le shell c'est le bon vieux ''mode texte'', mon copain le ''prompt'', qui sous Linux revêt une importance capitale. En effet, la philosophie Unix veut que toute action puisse être réalisée en ligne de commande, avant d'être accessible dans une boîte de dialogue. Ainsi de nombreuses applications X ne sont en fait que des ''front ends'' (des façades) à des applications en ligne de commande, se contentant de construire la bonne ligne de commande à partir de vos clics (XCDRoast / cdrecord, mkisofs, etc. ; kppp / pppd ; etc.).

Comme Linux prône le règne de la liberté, vous n'avez pas qu'un seul ''shell'' disponible. Vous pouvez utiliser '''bash''', '''tcsh''', '''ksh''', '''ash''', '''sh''', '''csh''', etc. Néanmoins, la plupart des distributions actuelles proposent '''bash''' par défaut, et je vous recommande donc de l'utiliser, surtout si vous débutez sous Unix et que vous n'avez pas encore d'habitudes. Si plus tard, vous tombez sur un ordinateur ne disposant que de tcsh, ne vous inquiétez pas : la différence n'est pas flagrante, et vous pourrez toujours consulter "<code>man tcsh</code>" ! <br />''à noter que le choix du shell pour un utilisateur se configure dans <code>/etc/passwd</code>.''

Le shell n'est pas seulement le prompt vous permettant de taper vos commandes, c'est aussi un puissant ''langage de commande'', vous permettant d'automatiser des tâches, etc. via l'écriture de ''scripts shell''. Apprendre le langage du shell peut être très enrichissant et utile ; néanmoins, cela dépasse le cadre de cette rubrique. Et pis j'ai pas le courage de taper une leçon sur bash :) Par contre, vous trouverez ici les commandes de base, ainsi que les raccourcis clavier et les raccourcis du shell, les aliases, les variables d'environnement, la configuration du shell et j'en passe. C'est déjà pas mal non ?

----

== Commandes pour débuter ==

Avant de commencer, il faut savoir que Linux est '''sensible à la casse''' (''case sensitive'' en anglais), c'est à dire qu'il distingue les majuscules des minuscules. Ainsi, si je vous dit que la commande est '<code>mkdir</code>', ce n'est pas la peine d'essayer <code>MKDIR</code> ou <code>mKdiR</code>, cela ne fonctionnera pas. De même, les noms de fichiers et de répertoires sont également sensibles à la casse.

De plus, sous Unix, les chemins sont séparés par des slash : écrivez <code>/etc/rc.d/init.d/xfs</code> mais jamais <code>etc\rc.d\init.d\xfs</code> par pitié :)

* '''Répertoires spéciaux''' :
<code>. </code> représente le répertoire courant,
<code>.. </code> représente le répertoire parent
<code>~ </code> représente le répertoire maison (home) de l'utilisateur
* '''Fichiers cachés''' :
sous Unix, les fichiers cachés commencent par un point. Par exemple, ~/.bashrc est un fichier caché, dans le répertoire maison de l'utilisateur, qui contient la configuration de son shell.
* '''Jokers''' : ? et *
Les caractères <code>?</code> et <code><nowiki>*</nowiki></code> dans les noms de fichiers et de répertoires permettent de représenter des caractères quelconques. '<code>?</code>' représente un seul caractère, tandis que '<code><nowiki>*</nowiki></code>' en représente un nombre quelconque.
Par exemple "<code><nowiki>*.jpg</nowiki></code>" représente tous les fichiers se terminant par <code>jpg</code> ; "<code><nowiki>*toto*</nowiki></code>" tous les fichiers contenant "<code>toto</code>". Oui vous avez bien vu : on peut mettre plusieurs étoiles en même temps !!! Vous pouvez même faire : <code>cd /et*/rc.*/init*</code>, cela risque de fonctionner !!!
Il faut également savoir que c'est le shell qui interprète ces caractères avant de transmettre la ligne de commande. Par exemple, si vous tapez : <code>rm -Rf *.tmp</code>, le shell transformera cette ligne de commande en : <code>rm truc1.tmp truc2.tmp truc3.tmp</code>.
* '''Jokers avancés''' : []
Vous pouvez aussi utiliser les crochets pour spécifier des caractères :
<code>[a]</code> signifie : égal à 'a'. Exemple : <code>rm *[a]*</code> efface tous les fichiers contenant la lettre 'a'.
<code>[!a]</code> signifie : différent de 'a'. Exemple : <code>rm *[!a]*</code> efface tous les fichiers, sauf ceux contenant la lettre 'a'.
<code>[abc]</code> signifie : l'un des caractères a, b ou c. Exemple : <code>rm [abc]*.tmp</code> efface tous les fichiers commençant par a, b ou c.
<code>[a-l]</code> : signifie : tous les caractères compris entre a et l. Exemple : <code>rm fic_[a-l]*</code> efface tous les fichiers commençant par <code>fic_</code> suivi d'une quelconque lettre entre a et l.

''Bon c'est pas tout ça, voici les commandes de base sous Linux :''

{| width="100%" border="1" cellpadding="5"
|- bgcolor="#CCCCCC"
| width="10%" |
<center>

Commandes linux

</center>
| width="10%" |
<center>

équivalent MsDos

</center>
| width="30%" |
<center>

à quoi ça sert

</center>
| width="50%" |
<center>

Exemples :

</center>
|-
|
'''<code>cd</code>'''
|
'''<code>cd</code>'''
|
change le répertoire courant.
|
<code>cd ..</code><br /> - va dans le répertoire parent du répertoire courant

<code>cd /home/user/.nsmail</code><br /> - va dans le répertoire désigné
|- bgcolor="#CCCCCC"
|
'''<code>ls</code>'''
|
'''<code>dir</code>'''
|
affiche le contenu d'un répertoire
|
<code>ls</code><br /> - affiche le contenu du répertoire courant

<code>ls -l</code><br /> - affiche le contenu du répertoire courant de manière détaillée

<code>ls -a /home/user</code><br /> - affiche le contenu du répertoire désigné (ainsi que les fichiers cachés)
|-
|
'''<code>cp</code>'''
|
'''<code>copy</code>'''<br />'''<code>xcopy</code>'''
|
copie un ou plusieurs fichiers
|
<code>cp toto /tmp</code><br /> - copie le fichier toto dans le répertoire <code>/tmp</code>

<code>cp toto titi</code><br /> - copie le fichier <code>toto</code> sur le fichier <code>titi</code>

<code>cp -R /home/user /tmp/bak</code><br /> - copie le répertoire <code>/home/user</code> ainsi que tout ce qu'il contient dans <code>/tmp/bak</code>
|- bgcolor="#CCCCCC"
|
'''<code>rm</code>'''
|
'''<code>del</code>'''
|
efface un ou plusieurs fichiers
|
<code>rm toto titi</code><br /> - efface les fichiers <code>toto</code> et <code>titi</code>

<code>rm -f toto titi</code><br /> - efface les fichiers <code>toto</code> et <code>titi</code> sans demander confirmation
|-
|
'''<code>rm -rf</code>'''
|
'''<code>deltree</code>'''
|
efface un répertoire et son contenu
|
<code>rm -rf /tmp/*</code><br /> - efface (sans demander de confirmation) tous les fichiers et répertoire de <code>/tmp</code>
|- bgcolor="#CCCCCC"
|
'''<code>mkdir</code>'''
|
'''<code>md</code>'''
|
crée un répertoire
|
<code>mkdir /home/user/mes_documents</code><br /> - crée le répertoire <code>mes_documents</code> dans le sous répertoire <code>/home/user</code> (ne pas mettre d'espace dans les noms de fichier)
|-
|
'''<code>rmdir</code>'''
|
'''<code>rm</code>'''
|
efface un répertoire s'il est vide
|
<code>rmdir /home/user/.nsmail</code><br /> - efface le répertoire <code>.nsmail</code> de <code>/home/user</code> si celui-ci est vide
|- bgcolor="#CCCCCC"
|
'''<code>mv</code>'''
|
'''<code>ren</code>'''<br />'''<code>move</code>'''
|
déplace ou renomme un ou des fichiers
|
<code>mv tata titi</code><br /> - renomme tata en titi

<code>mv * *.bak</code><br /> - ne fonctionne pas !!!!

<code>mv * /tmp/bak</code><br /> - déplace tous les fichiers du répertoire courant vers le répertoire <code>/tmp/bak</code>
|-
|
'''<code>find</code>'''
|
'''<code>dir -s</code>'''
|
trouve un fichier répondant à certains critères
|
<code>find /home -name "*bash*"</code><br /> - trouve tous les fichiers contenant le mot <code>bash</code> dans leur nom se trouvant dans le répertoire <code>/home</code>
|- bgcolor="#CCCCCC"
|
'''<code>locate</code>'''
|
'''<code>dir -s</code>'''
|
trouve un fichier d'après son nom
|
<code>locate bash</code><br /> - trouve tous les fichiers contenant le mot <code>bash</code> dans leur nom complet (avec le répertoire) : à la différence de <code>find</code>, locate trouve ses informations dans une base de donnée créée par <code>updatedb</code>
|-
|
'''<code>man</code>'''
|
'''<code>help</code>'''
|
affiche l'aide concernant une commande particulière
|
<code>man ls</code><br /> - affiche l'aide (page de <code>man</code>uel) de la commnade <code>ls</code>. On quitte man en appuyant sur la touche '<code>q</code>'
|- bgcolor="#CCCCCC"
|
'''<code>chmod</code>'''
|
pas <br /> d'équivalent
|
modifie les permissions d'un fichier
|
<code>chmod o+r /home/user</code><br /> - autorise les autres (<code>o=other</code>) (ie: ceux qui ne sont ni le propriétaire, ni membre du groupe propriétaire) à lire (<code>r=read</code>) le répertoire <code>/home/user</code>

<code>chmod a+rw /home/user/unfichier</code><br /> - autorise tout le monde (<code>a=all</code>) à lire et écrire (<code>w=write</code>) dans le fichier <code>/home/user/unfichier</code>
|-
|
'''<code>chown</code>'''
|
pas <br /> d'équivalent
|
modifie le propriétaire d'un fichier
|
<code>chown user unfichier</code><br /> rend <code>user</code> propriétaire de <code>unfichier</code>.
|- bgcolor="#CCCCCC"
|
'''<code>chgrp</code>'''
|
pas <br /> d'équivalent
|
modifie le groupe proprétaire d'un fichier
|
<code>chgrp -R nobody /home/httpd</code><br /> - rend le groupe : <code>nobody</code> (un groupe ayant très peu de droit sur un système linux) propriétaire de <code>/home/httpd</code> ainsi que tout les fichiers qu'il contient (<code>-R</code>)
|-
|
'''<code>ln -s</code>'''
|
pas <br /> d'équivalent
|
crée un lien vers un fichier
|
<code>ln -s /dev/fd0 /dev/disquette</code><br /> crée un lien vers <code>/dev/fd0</code> (le lecteur de disquette) nommé <code>/dev/disquette</code>. La manipulation de <code>/dev/fd0</code> et <code>/dev/disquette</code> (sauf l'effacement).
|- bgcolor="#CCCCCC"
|
'''<code>grep</code>'''
|
pas <br /> d'équivalent
|
recherche une chaine dans un fichier (en fait recherche une expression régulière dans plusieurs fichiers)
|
<code>grep chaine *.txt</code><br /> - recherche la chaine '<code>chaine</code>' dans tous les fichier se terminant par <code>.txt</code>.
|-
|
'''<code>which</code>'''
|
pas <br /> d'équivalent
|
trouve le répertoire dans lequel se trouve une commande
|
<code>which emacs</code><br /> - retourne le nom du répertoire dans lequel se trouve la commande <code>emacs</code>.
|- bgcolor="#CCCCCC"
|
'''<code>cat</code>'''
|
'''<code>type</code>'''
|
affiche un fichier à l'écran
|
<code>cat ~/.bashrc</code><br /> - affiche le contenu du fichier <code>~/.bashrc</code>
|}

<u>Remarque</u> : <br /> Pour en savoir plus sur toutes ces commandes, je vous conseille de consulter leur page de man !

=== La commande <code>ls</code> ===

Cette commande est omniprésente, aussi il est bon d'en présenter les basiques.

Afficher le listing page par page : <code>ls | less</code> (<code>less</code> est une version améliorée de <code>more</code>) <br /> Afficher le listing en couleurs : <code>ls --color</code><br /> Afficher aussi les fichiers cachés (commençant par un point) : <code>ls -a</code><br /> Mettre un '/' après les noms de répertoires : <code>ls -p</code><br /> Afficher le listing détaillé : <code>ls -l</code>

<u>Tri sur la date</u><br /> Pour afficher les fichiers d'un répertoire en triant sur la date de mise à jour des fichiers <br /> Afficher les fichiers les plus récents en premier : <code>ls -t</code><br /> Afficher les fichiers les plus vieux en premier : <code>ls -rt</code><br /> Mixer avec l'option "l" afin d'afficher le listing détaillé : <code>ls -rtl</code> ou <code>ls -tl</code>

''bien sûr, toutes ces options sont mixables,'' ainsi "<code>ls -altp</code>" affiche tous les fichiers, de façon détaillée, dans l'ordre chronologique, an ajoutant '/' après chaque nom de répertoire.

<u>Exemple de listing</u>

<div class="code">'''[jice@taz jice]$'''ls -alp <br /><font size="-1">total 144</font><br /> -rw-r--r-- 1 jice users 24 Aug 2 21:37 .bash_logout <br /> -rw-r--r-- 1 jice users 230 Aug 2 21:37 .bash_profile <br /> -rw-r--r-- 1 jice users 467 Aug 2 21:37 .bashrc <br /> -rw-r--r-- 1 jice users 1452 Aug 2 21:37 .kderc <br /> drwxr--r-- 12 jice users 1024 Aug 2 21:37 .kde/ <br /> drwxr--r-- 2 jice users 1024 Aug 2 21:37 Desktop/ <br /> -rw-r----- 1 jice users 1728 Aug 2 21:37 adresses.txt <br /> -rw------- 1 jice users 144 Aug 2 21:37 motsdepasse.txt <br /> lrwxrwxrwx 1 jice users 14 Aug 2 21:37 linux -> /usr/src/linux</div>

<u>Explication :</u><br /> La première ligne "total 144" est l'espace disque utilisé par l'ensemble des fichiers du répertoire.

# La première colonne <code>-rw-r--r--</code>représente les '''permissions''' associées au fichier. le premier caractère est un tiret pour un fichier, un d pour un répertoire, un l pour un lien, etc. <br /> ensuite, on a trois groupes de trois caractères : <code>rw-</code> ou <code>r--</code> ou <code>rwx</code> ou... <br /> Le premier groupe représente les permissions associées à l'utilisateur (ici, jice), le deuxième celles associées à son groupe (ici : users), enfin le dernier est les permissions que tout le monde a sur ces fichiers. <br /><code>r</code> signifie : possibilité de lire ce fichier / dans ce répertoire, <br /><code>w</code> signifie : possibilité d'écrire dans ce fichier / répertoire, <br /><code>x</code> signifie : possibilité d'exécuter ce fichier / d'aller dans ce répertoire.
# nombre d'inodes (partie élémentaire de [../docs/glossaire.php3#systeme_fichiers système de fichiers]) qui pointent vers le fichier/répertoire (généralement 1 pour un fichier, 2+le nombre de sous-répertoires pour un répertoire).
# utilisateur à qui appartient le fichier (jice)
# groupe auquel le fichier appartient (users)
# taille en octets
# date et heure de modification
# nom du fichier/répertoire.

----

== Quelques questions et réponses ==

Les commandes du tableau ci-dessus permettent de répondre à quelques questions comme : <br /> Où est cette commande (which) ? Que contient ce fichier (cat ou tac) ? Quel fichier contient tel mot (grep) ? etc. <br /> Voici d'autres questions et réponses qui ne nécessitent pas d'être root et vous permettront de continuer à vous familiariser avec bash et ses commandes. Elles sont regroupées en trois tableaux : Informations sur les commandes ; informations sur le système ; informations sur les fichiers.

=== Informations sur les commandes ===

{| width="100%" border="1" cellpadding="5"
| width="20%" |
'''Quelle commande utiliser pour faire ... ceci ou cela ?'''
|
<code>apropos mot_clef</code> ou <code>man -k mot_clef</code><br />     - affiche les commandes, brièvement définies, en rapport avec mot_clef. <br /><code>apropos copier</code><br />     - affiche les commandes en rapport avec la copie d'un fichier, d'une chaîne, d'une zone mémoire ... <br /><code>apropos permission</code><br />     - affiche les commandes liées à la vérification et à la modification des permissions.

Notes : les noms communs et les verbes à l'infinitif permettent généralement de trouver facilement la commande recherchée. En cas d'échec, pensez aux synonymes : apropos supprimer fait apparaître la commande rmdir (supprimer un répertoire), alors que apropos effacer fait apparaître la commande rm (effacer un fichier).
|-
|
'''Comment se définit cette commande ?'''
|
<code>whatis nom_commande</code> ou <code>man -f nom_commande</code><br />     - affiche une brève définition de nom_commande. <br /><code>whatis whatis</code><br />     - affiche la définition de whatis. <br /><code>whatis arch</code><br />     - affiche la définition de la commande arch. <br /><code>cd /bin ; for i in * ; do whatis $i ; done | more ; cd</code><br />     - se positionne dans le répertoire /bin/, affiche page par page la définition de chacune des commandes qui s'y trouve, retourne au répertoire personnel.

Notes : dans l'exemple précédant vous pouvez bien sûr remplacer /bin par /sbin ; certaines entrées échouent.
|-
|
'''Quelles sont et comment utiliser les commandes internes ?'''
|
<code>help</code><br />     - affiche la liste des commandes internes et leur syntaxe. <br /><code>help nom_commande</code><br />     - affiche une aide sommaire sur nom_commande. <br /><code>help help</code><br />    - affiche une aide sur help. <br /><code>help alias</code><br />     - affiche une aide sur la commande alias.

Notes : ces commandes sont les commandes internes du shell, généralement le bash. Vous pouvez aussi en obtenir la liste en demandant à propos de l'une d'elles une page man qui n'existe pas (man :). Vous trouverez également une aide sur les commandes internes dans la page man de bash (man bash). Enfin notez que help concerne les commandes internes mais --help les commandes externes.
|-
|
<br />'''Où sont et quelles sont les commandes externes ?'''
|
<code>ls /bin</code><br />     - affiche le contenu du répertoire /bin/, et donc la liste des commandes externes usuelles communes à tous les utilisateurs. <br /><code>ls /sbin</code><br />     - affiche le contenu du répertoire /sbin/, et donc la liste des commandes externes usuelles réservées à l'administrateur (root). <br /><code>whereis nom_commande</code><br />     - affiche le chemin de nom_commande ainsi que celui de sa page man. <br /><code>whereis cat</code><br />     - affiche le chemin de la commande cat (/bin/cat) et celui de sa page man (/usr/share/man/man1/cat.1.bz2). <br /><code>which nom_commande</code><br />     - affiche le chemin de nom_commande. <br /><code>which tac</code><br />     - affiche le chemin de tac (/usr/bin/tac).

Notes : les répertoires /usr/bin/ et /usr/sbin/ contiennent les commandes externes moins fréquemment utilisées. Pour savoir si une commande est externe vous pouvez aussi simplement vérifier qu'elle n'est pas interne !
|-
|
'''Comment obtenir un aide mémoire sur cette commande ?'''
|
<code>nom_commande --help</code><br />     - affiche l'aide mémoire de nom commande. <br /><code>ls --help</code><br />     - affiche l'aide mémoire de la commande ls.

Notes : --help concerne la plupart des commandes externes et help les commandes internes. echo --help affiche bien sûr ... --help.
|-
|
'''La dernière commande s'est-elle bien terminée ?'''
|
<code>echo $?</code><br />     - affiche le code de retour de la dernière commande effectuée, 0 si elle s'est bien terminée, un autre nombre dans le cas contraire. <br /><code>clear ; echo $?</code><br />     - efface l'écran et affiche 0. <br /><code>sl / ; echo $?</code><br />     - affiche un message d'erreur et le code 127 (bash ne connaît pas la commande sl). <br /><code>nom_commande 2>/dev/null && echo "ok" || echo "m'enfin"</code><br />     - exécute nom_commande en redirigeant les erreurs vers /dev/null (périphérique fictif) puis affiche "ok" si tout s'est bien passé ou "m'enfin" dans le cas contraire. <br /><code><nowiki>: && echo "ok" || echo "m'enfin"</nowiki></code><br />     - ne fait rien puis affiche "ok" (la commande : ne fait rien et se termine toujours bien). <br /><code>bof 2>/dev/null && echo "ok" || echo "m'enfin"</code><br />     - affiche "m'enfin" (la commande bof n'existe pas).

Notes : commande1 && commande2 exécute commande2 que si commande1 s'est terminée normalement (0) ; commande1 || commande2 exécute commande2 que si commande1 ne s'est pas terminée correctement (<>0).
|-
| width="20%" |
'''Quels sont le nom, la taille et le contenu du fichier d'historique ?'''
|
<code>echo $HISTFILE $HISTFILESIZE</code><br />     - affiche le nom et la taille du fichier d'historique des commandes. <br /><code>cat $HISTFILE | more</code><br />     - affiche le contenu du fichier d'historique page par page. <br /><code>tail -n 24 $HISTFILE</code><br />     - affiche les 24 dernières lignes du fichier d'historique.

Notes : le fichier d'historique vous aide à répondre à la question : mais comment j'avais fait ? et à en conserver une trace d'une connexion à l'autre.
|-
|
'''Quel est l'historique actuel ?'''
|
<code>history | more</code><br />     - affiche page par page le contenu numéroté de l'historique actuel des commandes. <br /><code>history 12</code><br />     - affiche les 12 dernières entrées effectuées et leurs numéros.

Notes : c'est cet historique qui défile avec les touches "flèches" de votre clavier ; au démarrage, c'est le contenu de votre fichier d'historique.
|}

=== Informations sur le système ===

{| width="100%" border="1" cellpadding="5"
| width="20%" |
'''Quel est le système ?'''
|
<code>uname</code> ou <code>echo $OSTYPE</code><br />     - affiche le nom du système d'exploitation. <br /><code>uname -a</code><br />     - affiche diverses informations système (nom du SE, version, microprocesseur ...). <br /><code>arch</code> ou <code>uname -m</code><br />     - affiche le type du microprocesseur. <br /><code>cat /proc/cpuinfo</code><br />     - affiche des informations sur le microprocesseur (type, fréquence, cache ...).

Notes : les informations recueillies avec uname -a peuvent aussi être obtenues avec certaines variables système : echo $OSTYPE $BASH $BASH_VERSION etc.
|-
|
'''Depuis combien de temps ce shell est-il actif ?'''
|
<code>uptime</code><br />     - affiche l'heure, la durée d'activité du système, le nombre d'utilisateurs ... <br /><code>echo $SECONDS</code><br />     - affiche la durée d'activité du shell courant en secondes. <br /> echo $[$SECONDS/3600] h $[($SECONDS%3600)/60] mn $[$SECONDS%60] s <br />     - affiche cette durée en heures, minutes et secondes.

Notes : bash ne connaît que les entiers et donc que les divisions euclidiennes, / permet d'en obtenir le quotient et % d'en obtenir le reste (ou modulo). Chaque fois que vous changez de terminal, ouvrez un nouvel xterm ou faites un su, celui-ci correspond à un nouveau (sous)shell, sa variable SECONDS est donc alors à 0. Pour savoir depuis combien de temps vous êtes sous Linux, revenez à votre console de login ; pour savoir depuis quand le système est actif, utilisez uptime.
|-
|
'''Qu'en est-il des disques, de la mémoire, du microprocesseur ?'''
|
<code>mount</code><br />     - affiche la liste des disques montés. <br /><code>df -ah</code><br />     - affiche au format humain l'espace total, occupé, libre sur tous les disques. <br /><code>free</code> ou <code>cat /proc/meminfo</code><br />     - affiche des informations sur la mémoire (totale, libre, swap ...). <br /><code>vmstat</code><br />     - affiche les statistiques sur la mémoire virtuelle. <br /><code>top</code><br />     - affiche et permet d'observer en temps réel l'activité de la mémoire et du microprocesseur.

Notes : la touche <Q> permet de quitter la commande top.
|-
|
'''Quelles sont et que signifient les variables système ?'''
|
<code>$<Tab></code><br />     - affiche les noms des principales variables système. <br /><code>help variables | more</code><br />     - affiche page par page la définition des principales variables système.

Notes : les noms des variables système sont généralement écrits en majuscules. A chacune de ces variables correspond une question et une réponse, quelques unes seulement ont été formulées à divers endroits dans cette page.
|-
|
'''Que contiennent ces variables système ?'''
|
<code>echo $NOM_VARIABLE</code><br />     - affiche le contenu de NOM_VARIABLE. <br /><code>echo $USER</code><br />     - affiche le nom de l'utilisateur en cours. <br /><code>echo $PS1</code><br />     - affiche la chaîne de caractères définissant le prompt. <br /><code>printenv | more</code><br />     - affiche page par page l'environnement. <br /><code>set | more</code><br />     - affiche page par page le contenu des principales variables système.

Notes : vous pouvez bien sûr modifier le prompt PS1="chaîne de caractères". Pour rendre cette modification générale et durable, il faut utiliser le fichier /etc/bashrc (nécessite d'être root).
|-
|
'''Qui suis-je et qui est ou était connecté au système ?'''
|
<code>id nom_utilisateur</code><br />     - affiche les identifications de nom_utilisateur. <br /><code>id</code><br />     - affiche vos identifications : UID, GDI, groupes. <br /><code>who am i</code><br />     - affiche vos coordonnées dans le système. <br /><code>who -H</code><br />     - affiche avec une entête des informations (nom de login, console ... ) sur les utilisateurs connectés. <br /><code>w </code><br />     - affiche qui est connecté (who -H) et aussi ce qu'il fait. <br /><code>last -n 12</code><br />     - affiche la liste des 12 dernières connexions.

Notes : la commande who am i ne fonctionne pas toujours sous xterm, dans ce cas entrez whoami mais vous n'obtiendrez que votre nom de login. De nombreuses commandes permettent d'obtenir une partie des renseignements évoqués ci-dessus, leurs noms parlent d'eux-mêmes : logname, users, groups ...
|-
|
'''Quelles sont la date et l'heure ?'''
|
<code>date</code><br />     - affiche la date et l'heure. br /><code>date +%x</code><br />     - affiche seulement la date au format jj.mm.aaaa. <br /><code>date +%X</code><br />     - affiche uniquement l'heure au format hh:mm:ss. <br /><code>cal</code><br />     - affiche un calendrier du mois en cours. <br /><code>cal 2000</code><br />     - affiche le calendrier de l'an 2000, etc.
|-
|
'''Y a-t-il un manchot dans le système ?'''
|
<code>linux_logo</code><br />     - affiche Tux et diverses informations système. <br /><code>linux_logo -la</code><br />     - affiche Tux en ASCII et sans informations :-)

Notes : sur mon système, linux_logo -la produit bien l'affichage attendu (-a = ASCII et -l = pas d'informations) mais avec linux_logo -al, l'option -l est ignorée et les informations sont affichées ... Y a-t-il un bug dans mon système ?
|}

=== Informations sur les fichiers ===

{| width="100%" border="1" cellpadding="5"
| width="20%" |
'''Quel est le répertoire courant ?'''
|
<code>pwd</code><br />     - affiche le nom complet du répertoire en cours.
|-
|
'''Quelle est la taille de ce répertoire ?'''
|
<code>du -sh </code><br />     - affiche au format humain la taille du répertoire courant. <br /><code>du -h ~ | more</code><br />     - affiche page par page au format humain la taille de votre répertoire personnel et de tous ses (sous)répertoires.

Notes : du ne fonctionne que sur les répertoires où vous avez droit d'accès, si nécessaire passez sous root.
|-
|
'''Quel est le type de ce fichier ?'''
|
<code>file nom_fichier</code><br />     - affiche le type de nom_fichier. <br /><code>file *</code><br />     - affiche le type de tous les fichiers du répertoire en cours. <br /><code>file /bin</code><br />     - affiche que /bin/ est un répertoire. <br /><code>file /bin/sh</code><br />     - affiche que sh est un lien symbolique vers bash. <br /><code>file /bin/bash</code><br />     - affiche que bash est un exécutable. <br /><code>file ~/.bashrc</code><br />     - affiche que .bashrc de votre répertoire personnel est un fichier texte. <br /><code>file /dev/null</code><br />     - affiche que null est un fichier spécial.

Notes : file sait reconnaître un grand nombre de types de fichiers parmi les fichiers spéciaux, exécutables, textes, données ... Il est préférable de l'utiliser avant d'entrer un "cat" au hasard.
|}

----

== Raccourcis ==

=== Clavier ===

* '''Tab'''
Taper une fois la touche [Tab] permet de compléter automatiquement un nom de fichier/répertoire s'il est unique :
<div class="code">'''[user@localhost user]$''' cd /et'''[Tab]'''<br />'''[user@localhost user]$''' cd /etc_</div>
* '''Tab Tab'''
Si lors du premier appui sur [Tab], le nom n'a pas été complété, un deuxième appui vous donne la liste de toues les possibilités :
<div class="code">'''[user@localhost user]$''' cd /usr/doc/H'''[Tab][Tab]'''<br /> HTML    HOWTO<br />'''[user@localhost user]$''' cd /usr/doc/H_</div>
* '''Flèche vers le haut (ou Ctrl-P) / bas (ou Ctrl-N)'''
La flèche vers le haut permet de remonter dans l'historique des commandes, la flèche vers le bas permet de revenir. Vous pouvez aussi utiliser la commande <code>fc</code>, consultez <code>man fc</code>.
* '''Shift - flèche vers le haut/bas'''
Permet de scroller le contenu du terminal texte vers le haut ou le bas, d'une ligne. En effet, les lignes qui ont défilé vers le haut restent en mémoire et restent accessibles. Terrible, non ?
* '''Shift - Page up/down'''
La même chose, mais page par page.
* '''Ctrl-C'''
Arrête le processus en cours, celui qui a été lancé par la dernière commande.
* '''Ctrl-Z'''
Stoppe le processus en cours, celui qui a été lancé par la dernière commande, mais ne le détruit pas : il reste en attente. Pour le mettre en tâche de fond (il continue à s'exécuter, mais vous pouvez continuer à taper des commandes), tapez '''<code>bg</code>'''. Pour le faire revenir en avant, taper '''<code>fg</code>'''.
* '''Ctrl-D'''
Ferme le terminal en cours (similaire à <code>exit</code> ou <code>logout</code>).

et aussi...

* '''Ctrl-Alt-Fn'''
Se place sur la console virtuelle numéro '''n'''. Par défaut, il y a en général 6 consoles texte virtuelles, de F1 à F6, et X Window se lance dans la septième (F7).
* '''Ctrl-Alt-Backspace'''
Cela permet de tuer X et de revenir soit à la [../docs/glossaire.php3#display_manager bannière de login] soit au shell qui a lancé X par <code>startx</code>. A éviter si possible : il est plus sain de quitter X en se déconnectant proprement.
* '''Ctrl-Alt-Del'''
Suivant votre configuration, ces touches à l'action bien connue vous permettrons de rebooter votre ordinateur (synonyme de <code>reboot</code> ou <code>shutdown -r now</code>). Si vous souhaitez juste arrêter votre ordinateur afin de l'éteindre, tapez <code>halt</code>, ou <code>shutdown -h now</code>.

=== Shell ===

Les shells Unix disposent de petits "raccourcis" très astucieux et utiles, qui vous épargnerons de taper sur quelques touches. Ne dit-on pas qu'un bon informaticien est un informaticien fainéant ? :-)

'''Dernière ligne de commande : <code>!!</code>'''

On a vu plus haut qu'elle était accessible par la flèche vers le haut, mais vous pouvez également la désigner par '<code>!!</code>', ce qui peut être très intéressant.

<div class="code">'''[user@localhost user]$''' vi<br />'''[user@localhost user]$''' which !!<br /> which vi<br /> /bin/vi</div>

'''Arguments de la dernière commande : <code>!*</code>'''

Les arguments de la dernière commande peuvent être représentés par '<code>!*</code>'.

<div class="code">'''[user@localhost user]$''' mkdir test<br />'''[user@localhost user]$''' cd !<br /> cd test</div>

'''Utiliser la sortie d'une commande comme argument :'''

Vous pouvez réutiliser directement ce qu'une commande écrit à l'écran comme argument pour une autre commande. Pour ce faire, vous devez encadrer la commande par une cote inverse <code>`</code> ou la mettre entre parenthèses précédées du signe $ ; elle sera remplacée par ce qu'elle écrit à l'écran dans la ligne de commande. Imaginez par exemple que vous vouliez voir les informations sur le fichier exécutable de emacs.

<div class="code">'''[user@localhost user]$''' ls -l `which emacs`<br />'''[user@localhost user]$''' ls -l $(which emacs)</div>

est ainsi équivalent à :

<div class="code">'''[user@localhost user]$''' which emacs<br /> /usr/bin/emacs<br />'''[user@localhost user]$''' ls -l /usr/bin/emacs</div>

Cool non ? Et vous pouvez mixer les raccourcis vus précédemment :

<div class="code">'''[user@localhost user]$''' emacs<br />'''[user@localhost user]$''' ls -l `which !!`</div>

C'est-y pas beau ça madame ?

'''Remplacer un caractère par un autre : <code>^</code>'''

Si vous souhaitez remplacer la première occurrence d'un caractère de la ligne de commande précédente par un autre, vous pouvez utiliser le symbole <code>^</code>, comme ci-dessous :

<div class="code">'''[user@localhost user]$''' lpcate i486-linux-libc5<br /> lpcate : command not found<br />'''[user@localhost user]$''' ^p^o<br /> locate i486-linux-libc5</div>

<code>^p^o</code> signifie : refait la même ligne de commande que précédemment, mais remplace le premier p par un o.

'''Lancer un programme directement en tâche de fond : &'''

Il suffit de faire suivre la ligne de commande du symbole <code>&</code> :

<div class="code">'''[user@localhost user]$''' cp -R /usr/doc /tmp &<br /> [1] 7194<br />'''[user@localhost user]$''' _</div>

La commande est lancée en tâche de fond, c'est à dire qu'elle s'exécute, mais la main vous est rendue tout de suite. La fin de la commande est signifiée par un message :

<div class="code">'''[user@localhost user]$'''<br /> [1]+ Done cp -R /usr/doc /tmp<br />'''[user@localhost user]$''' _ </div>

'''Lancer plusieurs programmes en même temps : &, &&, <code>||</code>, <code><nowiki>;</nowiki></code>'''

Vous avez plusieurs solutions :

<code>prog1 ; prog2 </code> lance prog1, puis prog2,

<code>prog1 & prog2 </code> lance prog1 en arrière plan, puis immédiatement prog2 en avant plan,

<code>prog1 && prog2</code> lance prog1, puis prog2 seulement si prog1 n'a pas retourné d'erreur,

<code>prog1 || prog2</code> lance prog1, puis prog2 seulement si prog1 A retourné une erreur.

----

== Redirections ==

Normalement, la sortie des programmes se fait à l'écran, aussi bien pour les erreurs (''standard error'') que pour les messages "normaux" (''standard output''). Vous pouvez la rediriger, soit vers un fichier avec <code>></code>, soit vers l'entrée d'un autre programme avec <code>|</code> (ou pipe - attention, arrêtez de rigoler dans le fond :-).

De même, l'entrée standard (''standard input'') est habituellement constituée du clavier, mais on peut aussi la remplacer par le contenu d'un fichier, avec le symbole <code><</code>.

=== Envoyer la sortie standard d'un programme dans l'entrée standard d'un autre ===

Vous avez déjà certainement vu ou utilisé une commande du type :

<div class="code">'''[user@localhost user]$''' ls -la '''<font size="+1">|</font>''' more</div>

<code>ls -la</code> envoie la version longue du listing de répertoire, avec les fichier cachés, à <code>more</code> qui l'affiche page par page. <br /> Vous pouvez aussi enchaîner plusieurs redirections :

<div class="code">'''[user@localhost user]$''' cat /var/log/messages '''|''' grep gpm '''|''' more</div>

Ceci va afficher page par page l'ensemble des messages système relatifs à <code>gpm</code>. (voir plus haut ce que font chacune de ces commandes).

=== Envoi d'un fichier dans l'entrée standard ===

L'entrée standard (''standard input'') est normalement ce que vous tapez au clavier. Vous pouvez remplacer vos frappes clavier par le contenu d'un fichier, qui sera ouvert et envoyé sur l'entrée standard du programme. C'est pratique pour automatiser des tâches avec des programmes interactifs. Exemple :

<div class="code">'''[user@localhost user]$''' ftp < sessiontype.txt </div>

Ici le fichier <code>sessiontype.txt</code> pourra contenir par exemple :

<div class="code"> open ftp.lesite.com<br /> user jice<br /> pass xxxxxx<br /> cd /pub/linux/doc<br /> bin<br /> get jice.jpg<br /> bye</div>

Et vous permettra en une seule commande de récupérer le fichier <code>jice.jpg</code> sur le site <code>ftp.lesite.com</code> (utile si ce fichier change et que vous voulez le mettre à jour régulièrement). Bref, à vous d'inventer la vie qui va avec :-)

=== Redirection des sorties vers un fichier ===

<div class="code">'''[user@localhost user]$''' ls -lR /cdrom '''<font size="+1">></font>''' cdrom.txt</div>

Cette commande va lister le contenu du cdrom, et enregistrer le résultat dans le fichier <code>cdrom.txt</code>. <br /> En mettant deux <code>></code> de suite, vous ajoutez au fichier :

<div class="code">'''[user@localhost user]$''' date '''<font size="+1">>></font>''' cdrom.txt</div>

Ceci va ajouter la date au fichier précédemment créé.

Les messages d'erreur peuvent être dirigés séparément dans un fichier avec '''<code>2></code>''' :

<div class="code">'''[user@localhost user]$''' startx > startx.log '''2>''' startx.err</div>

ou dirigés vers le même fichier que les messages normaux :

<div class="code">'''[user@localhost user]$''' startx > startx.log '''2>&1'''</div>
----

== Gestion des processus ==

Linux est ''multitâches'', ce qui signifie que plusieurs programmes (qui peuvent être à la fois des applications utilisateur ou des tâches système) peuvent tourner simultanément. On vient de voir qu'on pouvait lancer directement depuis un terminal texte une commande en tâche de fond, avec le symbole &. <br /> Comment gère-t-on ensuite ces processus ?

'''Lister les processus : <code>ps</code>'''

La liste des processus en cours pour un terminal donné s'obtient en tapant simplement la commande '''<code>ps</code>''' :

<div class="code"> PID TTY STAT TIME COMMAND<br /> 12 p1 S    0:00 bash<br /> 144 p1 S    0:01 emacs<br /> 1768 p1 R    0:00 ps</div>

Si vous voulez voir plus de processus, vous pouvez lister tous les processus d'un utilisateur par <code>ps U root</code> :

<div class="code">   PID TTY      STAT   TIME COMMAND<br />     1 ?        S      0:04 init<br />     2 ?        SW     0:00 [keventd]<br />     3 ?        SWN    0:00 [ksoftirqd_CPU0]<br /> ...</div>

Vous pouvez aussi voir l'ensemble des process d'un système par <code>ps aux</code>

'''Lister les jobs et les gérer : <code>jobs</code>, <code>fg</code>, <code>bg</code>'''

"job" est un mot qui désigne ici les programmes que vous avez lancé en arrière plan (tâche de fond) dans votre terminal. Pour lancer un job en arrière plan, vous pouvez :

lancer le programme par son nom, puis taper <span class="key">Ctrl-Z</span> pour le stopper, puis la commande '''<code>bg</code>''' pour l'envoyer en arrière plan (BackGround).

vous pouvez aussi simplement taper le nom de ce programme suivi par le symbole '''&'''.

Afin d'afficher une liste des jobs d'un terminal, tapez la commande '''<code>jobs</code>'''<nowiki>:</nowiki>

<div class="code">'''[user@localhost user]$''' find / -name "*a*" >A &<br /> [1] 7859<br />'''[user@localhost user]$''' jobs<br /> [1]+ Running find / -name "*a*" >A & </div>

Pour chacun de ces jobs, vous pouvez les faire revenir en avant plan avec la commande '''<code>fg</code>''' ; "<code>fg</code>" pour le dernier programme lancé en tâche de fond, "<code>fg %n</code>" pour le n<sup>ième</sup>.

'''Tuer un processus : <code>kill</code>, <code>killall</code>'''

Afin de terminer un processus qui ne répond plus, par exemple, on utilise la commande '''<code>kill</code>''', suivie du numéro de job (<code>%n</code>) ou du PID du programme à tuer. Par exemple, si <code>ps</code> donne le résultat ci-dessus, la commande "<code>kill 144</code>" arrêtera la tâche emacs. "<code>kill %1</code>" fera la même chose.

Vous pouvez également tuer des processus par leur nom avec la commande '''<code>killall</code>''' suivie du nom du processus à tuer, mais attention : TOUS les processus de l'utilisateur utilisant killall et portant le même nom seront tués. Par exemple, si vous tapez "<code>killall emacs</code>", non seulement la fenêtre emacs lancée depuis ce terminal sera supprimée, mais aussi tous les autres emacs lancés depuis un autre terminal par l'utilisateur.

Vous pouvez aussi passer un autre argument à kill et killall, qui est le ''signal'' à envoyer à la tâche (les ''signaux'' sont une manière de communiquer avec les applications sous Unix). Par exemple, si la tâche récalcitrante ne s'arrête pas avec un simple <code>kill 144</code>, essayez <code>kill -9 144</code>, ou <code>kill -QUIT 144</code>.

----

== Aliases et variables d'environnement ==

=== Aliases ===

Plutôt que de taper de longues commandes, ou bien parce que vous préférez vous rappeler d'un nom plutôt que du vrai nom Unix, vous pouvez définir des ''aliases''. Pour ce faire, utilisez la commande <code>alias</code> comme suit :

Si votre shell est '''bash''' ou sh ou ash (par défaut) :

<div class="code">alias md=mkdir <br /> alias ls='ls --color' <br /> alias eclip2='telnet eclip2.ec-lille.fr'</div>

Si votre shell est '''tcsh''' ou csh (par défaut) :

<div class="code">alias md mkdir <br /> alias ls 'ls --color' <br /> alias eclip2 'telnet eclip2.ec-lille.fr'</div>

Ainsi pourrez-vous taper <code>md</code> au lieu de <code>mkdir</code>, et <code>eclip2</code> pour vous connecter à cette machine via telnet ; la commande <code>ls</code> affichera une sortie en couleurs...

Le problème est que les aliases définis dans un terminal ne sont valables que dans celui-ci, et disparaîtrons à jamais dès que ce terminal sera fermé. Pour conserver des alias par-delà les connexions/déconnexions, regardez la [#configuration_shell configuration du shell] : vous pouvez définir vos aliases dans le fichier '''~/.bashrc'''.

=== Variables d'environnement, Path et Prompt ===

Les variables d'environnement servent à enregistrer des paramètres que les programmes peuvent lire ensuite. Elles sont désignées par un symbole <code>$</code> suivi de lettres, chiffres et symboles.

Par exemple, la variable <code>$HOME</code> est égale au répertoire maison de l'utilisateur en cours (en général <code>/home/user</code>).

De même, la variable <code>$PATH</code> représente le chemin de recherche que le shell va parcourir afin de trouver le fichier exécutable qui correspond à la commande que vous venez de taper. Par exemple, <code>$PATH = /bin:/usr/bin:/usr/local/bin</code>.

'''Créer ou modifier une variable d'environnement'''<br /> Si votre shell est '''bash''' ou sh ou ash (par défaut) :

<div class="code">export MAVARIABLE=mavaleur</div>

Si votre shell est '''tcsh''' ou csh (par défaut) :

<div class="code">setenv MAVARIABLE mavaleur</div>

Cette commande positionnera la variable <code>MAVARIABLE</code> à la valeur <code>mavaleur</code>. Vous pouvez le vérifier, en tapant la commande <code>echo $MAVARIABLE</code> qui écrira à l'écran "<code>mavaleur</code>".

Vous pouvez ainsi ajouter le chemin <code>/home/user/bin</code> à votre <code>$PATH</code> si vous installez des logiciels dans votre répertoire personnel par exemple. Sous bash, cela donnera : export <code>PATH=$PATH:/home/user/bin</code>. Cependant, de même que pour les aliases, ce nouveau PATH sera perdu dès votre déconnexion...

Attention, en général, le répertoire courant '<code>.</code>' ne fait pas partie du PATH pour des raisons de sécurité : imaginez qu'une personne mal intentionnée aie mis un programme destructeur appelé "<code>ls</code>" dans votre répertoire, vous le lanceriez dès que vous taperiez la commande <code>ls</code> ! C'est pourquoi il faut toujours faire précéder de son chemin complet une commande qui n'est pas dans le PATH, et ce même si vous êtes dans le même répertoire que la commande ! Ainsi, il ne faut pas taper <code>configure</code>, mais <code>./configure</code> (programme classique à lancer avant compilation d'un logiciel), ce qui signifie : lance le programme '<code>configure</code>' qui est présent dans le répertoire courant.

Le '''prompt''' est également contenu dans une variable d'environnement : <code>PS1</code>. <br /> Le prompt par défaut de la Mandrake par exemple, <code>[user@localhost user]$</code>, est défini comme suit : <code>PS1="[u@h W]$ "</code>. <br /><code>u</code> est l'utilisateur, <code>h</code> le nom de machine (hostname), <code>w</code> le chemin courant (ex : <code>/usr/doc</code>), <code>W</code> le répertoire courant (ex : <code>doc</code>)... voyez <code>man bash</code> pour l'ensemble des possibilités.

Une autre variable d'environnement utile : PROMPT_COMMAND. Cette variable contient une commande qui est exécutée à chaque fois que le prompt est affiché. Cela permet des tas de fantaisies rigolotes, comme par exemple de jouer un son (trop utile :-) ou de positionner le titre d'un xterm avec le nom du répertoire courant (voir <code>man xterm</code>).

Regardez la [#configuration_shell configuration du shell] : vous pouvez définir vos variables dans le fichier <code>~/.bash_profile</code>.

----

== Configuration du shell ==

Vous pouvez enregistrer des fichiers qui seront lus et exécutés par votre shell, lors de l'ouverture d'un terminal, aussi bien que lors de sa fermeture. Cela va vous permettre d'y placer vos aliases préférés, et vos variables d'environnement.

Pour '''bash''' et consorts, ces fichiers s'appellent : <code>.bashrc</code>, <code>.bash_profile</code> pour la connexion et <code>.bash_logout</code> pour la déconnexion. <br /> Pour '''tcsh''' et ses potes, ces fichiers s'appellent : <code>.tcshrc</code>, <code>.login</code> pour la connexion et <code>.logout</code> pour la déconnexion. <br /> Ces fichiers se situent tous dans le répertoire maison de l'utilisateur ($HOME). Notez bien qu'ils commencent par un point : ce sont des fichiers cachés. Pour les voir, il faut faire un "<code>ls -a</code>".

Examinez les avec votre éditeur de texte préféré, et vous verrez comment ajouter de nouveaux aliases et variables d'environnement, ainsi que lancer tel ou tel programme automatiquement : en tant que ''scripts shell'', ces programmes sont en fait une suite d'instructions qui sera interprétée par le shell.

----

== Les entrailles du shell ==

Vous êtes maintenant munis d'une jolie batterie d'outils qui va entre autres vous permettre d'écrire tous vos scripts shell. Toutefois même en ayant récupéré la synthaxe de commandes vous continuez à subir des erreurs... Soit la commande ne vous retourne pas le résultat attendu soit le shell vous retourne des erreurs... <br /> Ne vous êtes vous jamais posé cette question : est-ce que je mets des simples quotes, des doubles quotes ou des back quotes ? <br /> Pour ne plus avoir à se poser ce genre de questions, il est essentiel de bien connaitre le fonctionnement interne du shell.

=== Les grandes étapes de l'interprétation d'une ligne de commandes ===

Pour mieux comprendre le résultat obtenu, il faut savoir que le shell lit plusieurs fois la ligne avant d'exécuter la commande. <br /> Cette lecture se fait dans l'ordre suivant :

# substition de variables : le shell remplace les variables par leurs valeurs
# substitution de commandes : le shell remplace une variable par son contenu qui est le résultat d'une commande
# interprétation des pipes et des redirections
# expansion des noms de fichiers : interprétation des caractères spéciaux pour compléter un nom de fichier et/ou de répertoire
# exécution de la commande

On se rend donc compte qu'un caractère spécial peut être interprété par le shell avant d'être interprété au sein de la commande.

'''Exemple''' : le caractère <code>"*"</code> peut être interprété par le shell (remplace 0 ou n caractères pour compléter un nom de fichier) ou par une commande comme <code>grep</code> (répète de 0 à n fois le caractère précédent dans une chaîne de caractères). Toutefois, sans précision dans la synthaxe, et selon les étapes ci-dessus, le caractère sera d'abord interprété par le shell. D'où quelques surprises dans le résultat de la commande.

=== L'interprétation des caractères spéciaux ===

Pour choisir de faire interpréter les caractères spéciaux par le shell ou la commande, il existe 3 possibilités :

* '''utilisation des doubles quotes''' (ou guillemets en bon français) : lorsque la chaîne de caractères est écrite entre guillemets, tous les caractères spéciaux perdent leur signification '''sauf''' : '''$ \''' et '''``''' (simples quotes).
exemple :
<div class="code">'''[user@localhost user]$''' echo * <br /> bidule fic1 fic2 truc</div>
'''<nowiki>*</nowiki>''' est un caractère spécial non protégé. Au premier passage du shell, il est donc interprété. Il signifie alors l'ensemble des fichiers du répertoire courant
<div class="code">'''[user@localhost user]$''' echo "*" <br /> * </div>
'''<nowiki>*</nowiki>''' est protégé par les guillemets. Il n'est donc pas interprété par le shell comme caractère spécial et devient un caractère pour la commande echo. Dans le cadre de cette commande, * n'a aucune signification particulière, il est donc affiché à l'écran tel que.
* '''utilisation des simples quotes''' : lorsque la chaîne de caractères est écrite entre simples quotes, tous les caractères spéciaux sans exception perdent leur signification pour le shell. Ils seront donc éventuellement interprété par la commande passée.
exemple : recherche des lignes d'un script utilisant la variable PATH
<div class="code">'''[user@localhost user]$''' grep $PATH /home/user/script <br />'''[user@localhost user]$'''</div>
Au premier passage, le shell interprète le '''$''' comme introduisant une variable. Il remplace donc la variable par son contenu puis exécute la commande <code>grep</code>. Il ne trouve donc aucune ligne comportant les chemins référencés dans PATH.
<div class="code">'''[user@localhost user]$''' grep '$PATH' /home/user/script <br /> echo $PATH <br />'''[user@localhost user]$''' </div>
Le shell n'interprète pas le '''$''' lors du premier passage car sa signification est annulée par les simples quotes. le $ est donc traité par la commande grep. Comme il n'a pas de signification particulière, il est interprété comme un caractère quelconque.
* annulation d'un caractère spécial avec \ : pour empêcher le shell d'interpréter un caractère spécial, il suffit de positionner un anti-slash devant le caractère spécial donné.
exemple : pour reprendre l'exemple précédent on aurait pu écrire aussi :
<div class="code">'''[user@localhost user]$''' grep \$PATH /home/user/script <br /> echo $PATH <br />'''[user@localhost user]$''' </div>

=== Liste des caractères spéciaux ===

Ci-dessous la liste des caractères spéciaux du shell :

{| width="75%" border="1" cellpadding="5"
|- bgcolor="#CCCCCC"
| width="8%" |
'''&'''
| width="92%" |
processus en arrière-plan
|-
| width="8%" |
'''~'''
| width="92%" |
home directory
|- bgcolor="#CCCCCC"
| width="8%" |
'''<nowiki>;</nowiki>'''
| width="92%" |
séparateur de commandes
|-
| width="8%" |
'''\'''
| width="92%" |
annulation d'un caractère spécial
|- bgcolor="#CCCCCC"
| width="8%" |
'''"'''
| width="92%" |
doubles quotes : encadre une chaîne de caractères et annule la signification de $, \ et '
|-
| width="8%" |
'''`'''
| width="92%" |
back quotes : substitution de commandes
|- bgcolor="#CCCCCC"
| width="8%" |
'''''''
| width="92%" |
simples quotes : encadre une chaîne de caractères et annule la signification de tous les caractères spéciaux
|-
| width="8%" |
'''<nowiki>#</nowiki>'''
| width="92%" |
commentaire
|- bgcolor="#CCCCCC"
| width="8%" |
'''( )'''
| width="92%" |
exécution d'un shell fils
|-
| width="8%" |
'''[ ]'''
| width="92%" |
test
|- bgcolor="#CCCCCC"
| width="8%" |
'''|'''
| width="92%" |
pipe
|-
| width="8%" |
'''$'''
| width="92%" |
variable
|- bgcolor="#CCCCCC"
| width="8%" |
'''<nowiki>*</nowiki>'''
| width="92%" |
remplace 0 ou n caractères
|-
| width="8%" |
'''!'''
| width="92%" |
négation d'un test
|- bgcolor="#CCCCCC"
| width="8%" |
'''?'''
| width="92%" |
remplace 1 caractère
|-
| width="8%" |
'''< >'''
| width="92%" |
redirections entrée, sortie
|- bgcolor="#CCCCCC"
| width="8%" |
'''$0...$9'''
| width="92%" |
variables de position
|}

=== Appel des commandes ===

Autre élément à connaître pour ne pas avoir de surprise : à quel type de commande ai-je à faire ? on distingue des grands types de commande

* des commandes internes au shell : elles sont exécutées dans le même shell. si elles sont lancées à partir du shell père, il n'y aura pas création de shell fils
* des programmes binaires exécutables
* des fichiers de commande (shell-scripts)
* des alias
* des fonctions

La difficulté c'est que le shell interprète une commande en suivant un ordre très précis :

* '''le chemin de la commande comporte un /''', il exécute donc la commande située dans ce chemin, il n'y a pas d'ambiguïté possible.
* '''le chemin de la commande ne comporte pas de /''', il cherche la commande en suivant les étapes suivantes : <br />
*# consultation de la liste des alias
*# consultations des fonctions chargées
*# consultations des commandes internes du shell
*# consultation de la variable PATH

Donc si vous tapez une commande quelleconque, un script shell par exemple, sans préciser le chemin, la consultation de la variable PATH n'arrive qu'en dernier. Attention si vous disposez d'un alias ou d'une fonction qui porte le même nom, il traitera l'alias ou la fonction.

Pour terminer 2 commandes utiles pour savoir à quel type de commande vous avez à faire :

* <code>'''type nom_de_commande'''</code> : permet de déterminer le type d'une commande (alias, fonction, commande interne...)
* <code>'''which nom_de_commande'''</code> : recherche le chemin de la commande dans PATH
exemples :
<div class="code">'''[user@localhost user]$''' type ls <br /> ls est un alias suivi pour /usr/bin/ls <br />'''[user@localhost user]$''' type cd <br /> cd est une commande prédéfinie du shell <br />'''[user@localhost user]$''' which pwd <br /> /usr/bin/pwd <br /> </div>

----

== Index des commandes ==

heu... bon là j'en ai marre, on verra ça plus tard ! <code><nowiki>:-)</nowiki></code>

Je place quand même ici 2 commandes qui peuvent être bien utiles :

'''<code>cal</code>''' : donne le calendrier du mois courant, <br /><code>cal 12 1999</code> : donne le calendrier de décembre 1999, <br /><code>cal 2000</code> : donne le calendrier des 12 mois de l'an 2000.

<code>'''factor''' 12456988</code> : donne la décomposition en produit de facteurs premiers du nombre 12456988 (soit 2 x 2 x 17 x 183191) - c'est très mathématique, mais ultra rapide et puissant.

Pour terminer cet article, je vous renvoie vers ce petit manuel de référence, qui contient l'ensemble des commandes usuelles :

* [http://www.softndesign.org/?page=manuels/unix-1.php〈=FR Débuter en shell],
* [http://www.softndesign.org/?page=manuels/unix-2.php〈=FR Petit manuel de référence],
* [http://www.softndesign.org/?page=manuels/unix-3.php〈=FR Pour aller plus loin].
et aussi :
* [http://club.mandriva.com/xwiki/bin/KB/BasicsIndex#shell〈=FR Les bases du shell]

<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Jean-Christophe Cardot le 02/11/1999.</div>

= Copyright =
Copyright © 02/11/1999, Jean-Christophe Cardot
{{CC-BY-NC-SA}}