cbi

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Foire aux questions ======

Cette foire aux questions dépasse le niveau qui vous est demandé pour le module. Elle est là pour vous être utile tout au long de votre scolarité à l'UFR de mathématique et d'Informatique de Paris Descartes. 


===== Généralités =====

<hidden  Où trouver de l'aide sous linux ?> 
Voici différents endroits où trouver de l'aide sous linux :
  * **man** : si vous cherchez de l'aide sur une commande précise, ou même sur une fonction shell, perl ou C, man est un manuel en console, très complet, qui vous indiquera toutes les options et paramètres de chaque programme.
  * le répertoire ''/usr/share/doc/'' est très souvent utilisé par les programmes pour y stocker toute leur documentation dans un sous-répertoire propre : vous y trouverez des fichiers texte, des fichiers html, des fichiers exemples, mais aussi des utilitaires spécifiques pour vous aider à configurer ou bien utiliser l'application.
  * les **howtos** : format de présentation spécialement inventé pour linux, les "howtos" sont des tutoriaux répondant à une question précise et décrivant les étapes pour y arriver. Cette documentation est à l'origine en anglais mais est traduite pour une bonne part en français. [[http://www.tldp.org/HOWTO/HOWTO-INDEX/howtos.html|Liste officielle des howtos du Linux Documentation Project]].
  * chaque distribution a ses spécificités, il est donc vivement recommandé de consulter son manuel papier ou électronique, très souvent inclus au format html dans la distribution même ou sur le CD d'installation, de même que sur le site web. Par exemple le site de la distribution Debian contient une documentation très complète en ligne, correspondant à tous types de besoin (installation, prise en main, configuration, guide de référence... ) : [[http://www.debian.org/doc/|http://www.debian.org/doc/]].
  * le moteur de recherche Google vous aidera à trouver rapidement des tutoriaux sur ce que vous avez besoin des sites spécialisés comme developpez.com regorgent de tutoriaux, FAQ et articles divers sur des tas de manipulations courantes et avancées sous linux, il y a de bonnes chances que vous y trouviez votre bonheur.
</hidden>


===== Quelques définitions =====

<hidden  Qu'est-ce que Linux ?>
Linux est un système d'exploitation dérivé d'Unix, né en 1991. Initialement écrit pour processeur Intel 80x86 par le Finlandais Linus Torvalds, Linux est aujourd'hui un système multi-architectures (sparc, alpha, etc), auquel contribue une très large communauté de développeurs, et qui concurrence très sérieusement les Unix commerciaux... ainsi que Windows ;) En principe, Linux est gratuit, son code source est totalement ouvert et téléchargeable à partir de sites web. Ce qui n'est pas obligatoirement le cas pour les logiciels conçus pour lui, qui peuvent être non open-source et/ou payant. Linux se décline sous forme de distributions qui sont nombreuses et variées. Les distributions fournissent :
  * un installateur
  * des paquetages (ou packages) : programmes ou lots de programmes regroupés sous un même nom
  * un système d'installation de paquetages
  * des programmes spécifiques à la distribution
  * etc.
Ces distributions peuvent être soit gratuites (Debian, Slackware...) soit payantes (Suse). Mais toutes sont bâties à partir du noyau linux.
</hidden>
 
<hidden  Qu'est-ce que le projet GNU ?>
GNU est l'acronyme (récursif) de GNU Is Not Unix. C'est un projet né en 1984 sous l'initiative de Richard Stallman (et de la Free Software Foundation) dont l'objectif est de développer des logiciels open source. Bien qu'une version d'Unix (nommée Hurd) ne soit pas achevée, le projet GNU a engendré de très nombreux outils utilisés sous les différents Unix :
  * le compilateur C/C++ : gcc et g++
  * le debuggueur gdb
  * l'éditeur de texte emacs
  * etc.
Tous ces logiciels sont distribués sous la GNU General Public License (GPL), qui garantit les droits d'auteur sur les logiciels, mais autorise quiconque à copier, distribuer et modifier les sources. Linux est distribué sous licence GPL et intègre principalement des programmes GNU. C'est la raison pour laquelle on le nomme souvent GNU/Linux.
</hidden>

<hidden  Que sont les mans ?>
Les mans (pour "manuels") constituent une documentation pratique et centralisée des programmes présents sur votre distribution. Ce sont des fichiers texte (au format spécial "man") qui expliquent l'utilisation des programmes et détaillent leurs options. Ils se situent la plupart du temps dans le répertoire /usr/share/man/ (/usr/share/man/fr/ pour les mans traduits en français). Ils sont compressés pour un gain en place.
Vous pouvez les lire dans un terminal :
<code>
$ man cp
</code>
Les pages man sont scindées en huit sections :
  * Man 1 : Commandes utilisateur
  * Man 2 : Appels système
  * Man 3 : Utilisation de bibliothèques
  * Man 4 : Fichiers spéciaux
  * Man 5 : Formats de fichiers
  * Man 6 : Jeux
  * Man 7 : Packages
  * Man 8 : Commandes administrateur
  * Man 9 : Kernel
Pour en savoir plus :
<code>
$ man man
</code>

Pour faire une recherche par mots clés :
<code>
$ man -K mot_a_chercher
</code>
</hidden>

<hidden  A quoi correspondent les sigles i386, i486, i586 ... ?>
  * i386 : architecture x86 32 bits (386)
  * i586 : architecture x86 32 bits (Pentium, Pentium MMX ou compatibles AMD Duron jusqu'au K6-3)
  * i686 : architecture x86 32 bits (Pentium 2, 3 et 4 ou compatibles AMD)
  * PPC : Power PC (Apple Macintosh, essentiellement)
  * Alpha, sparc, SGI (Silicon Graphics)
Sous Linux, les commandes
<code>
$ arch
</code>
et
<code>
$ uname -m
</code>
vous donnent le type de votre architecture.
</hidden>

<hidden  Qu'est-ce qu'un 'gestionnaire de fenêtres' (window manager) ? >
Un gestionnaire de fenêtres est un programme s'appuyant sur le serveur graphique X, fournissant ainsi un environnement graphique plus ou moins avancé (gestion des workspaces, bindings clavier,...) sans suite logicielle (éditeur de texte, applications multimédia, browser internet,...)

Quelques gestionnaires de fenêtres : [[http://www.fvwm.org/|fvwm]], [[http://www.icewm.org/|icewm]], [[http://www.windowmaker.org/|window maker]], fluxbox,...
</hidden>

<hidden  Que sont les runlevels ? >
Les runlevels sont les niveaux d'exécution sous Linux. Ces niveaux de fonctionnement sont identifiés par des chiffres allant de 0 à 6 :
  * 0 : arrêt
  * 1 : niveau "single user" ou "failsafe", correspond au mode sans échec de windows, à n'utiliser qu'en cas de plantage sérieux pour réparer le système
  * 2 : niveau "multi user", sans réseau
  * 3 : niveau "multi user", avec réseau (mode console)
  * 4 : mode graphique sous Slackware, inutilisé ailleurs
  * 5 : mode graphique partout ailleurs
  * 6 : redémarre la machine

Le niveau d'exécution est déterminé (dans l'ordre) soit :
  * lors du boot : si vous précisez un niveau, en ligne de commande, au noyau (par exemple, au prompt LILO, taper "linux 1") dans le fichier ''/etc/inittab'', où le runlevel par défaut est défini
  * une fois loggé, vous pouvez utiliser la commande //init runlevel// qui permet de changer de runlevel.
</hidden>

<hidden  Qu'est-ce qu'un rootkit? >
Un rootkit est l'outil de prédilection d'un hacker unix. Après avoir réussi à s'introduire dans un système au moyen d'une faille de sécurité (bug dans un logiciel non mis à jour, mauvaise configuration laissant des accès ouverts, etc. ) et à obtenir un accès administrateur (root) lui donnant les pleins pouvoirs sur le système, l'assaillant essaiera d'installer un ensemble de scripts qui vont lui permettre de contrôler la machine compromise à distance : cet ensemble de programmes forme le rootkit.\\

Le rootkit va agir un peu à la manière d'un virus, ce qui est normal puisqu'un de ses buts essentiels est la dissimulation pour que personne ne remarque sa présence en utilisant la machine infectée. Pour passer inaperçu, le programme va donc classiquement modifier des bibliothèques systèmes (par exemple modifier des utilitaires comme netstat pour masquer les ports que le rootkit a ouvert, ou la commande ps qui devra masquer les processus parasites), modifier les logs pour effacer les traces de fonctionnement, etc. En plus de cela, il se chargera d'installer un programme de backdoor qui tournera en permanence et lui permettra de se connecter et lancer des commandes à distance via un client réseau qui tourne chez le pirate. Ces commandes peuvent être le lancement d'une attaque de déni de service distribué (DDoS) vers un autre système (très courant).\\

Si vous soupçonnez la présence d'un rootkit sur votre machine (plus lente que d'habitude à réagir, trafic réseau anormal, services ne répondant plus correctement... ), pensez à scanner votre machine avec un programme spécialisé comme chkrootkit, rkhunter ou d'autres. Pour prévenir les modifications des fichiers système, l'utilitaire [[http://tripwire.org/|tripwire]] est intéressant : il maintient en effet une base de données de signatures de contrôle des principaux fichiers système et est donc en mesure de signaler immédiatement toute altération de ceux-ci en comparant leur signature avec l'originale.
</hidden>

<hidden  Qu'est-ce qu'un daemon (démon) ? >
DAEMON est l'acronyme de Disk Activity and Execution MONitor. Cela désigne un processus qui tourne en tâche de fond et qui par là-même n'a donc pas d'interaction avec l'utilisateur.
</hidden>

<hidden  Qu'est ce que root ? >
Root est un utilisateur linux présent dans toutes les distributions linux. Il est aussi connu sous le nom de "super-utilisateur". Ce n'est pas un utilisateur comme les autres, il a absolument tous les droits et toutes les permissions sur la machine. \\

Il est conseillé de ne faire que le minimum d'opérations en mode root.
</hidden>


===== Installation =====

<hidden Quelle(s) distribution(s) pour les débutants ? >
Il est souvent conseillé de se faire les dents sur une distribution offrant des outils graphiques (donc supposés "simplifiés") d'installation et d'administration. Les principales différences entre les distributions de ce type reposent sur l'environnement graphique (KDE et Gnome étant les principaux), les outils d'administrations propres et le format des packages logiciels (deb, rpm...). Voici les distributions actuelles "grand public" les plus répandues :
  * [[http://www.ubuntu.com/|Ubuntu]] et ses dérivées : [[http://www.kubuntu.org/|Kubuntu]], [[http://www.xubuntu.org/|Xubuntu]], [[http://www.edubuntu.org/|Edubuntu]]
  * [[http://fedoraproject.org/|Fedora]] (version communautaire de la célèbre distribution Red Hat, devenue exclusivement commerciale)
  * [[http://www.mandriva.com/|Mandriva]]
  * [[http://www.suse.com/|Suse]]
Cependant, il est bon de se familiariser avec les outils en ligne de commande (d'autant qu'il est indispensable de comprendre ce qu'est un shell), et un éditeur de texte tel que nano ou vim. Ceci afin de mieux appréhender le fonctionnement du système et de pouvoir s'adapter plus facilement, par la suite, à une autre distribution. Quelques exemples de distributions plus difficiles à aborder mais néanmoins très puissantes : [[http://www.debian.org/|Debian]], [[http://www.slackware.org/|Slackware]], [[http://www.gentoo.org/|Gentoo]], etc. Si vous débutez votre découverte de linux, ne commencez pas par là ;)
</hidden>

<hidden Comment installe-t-on un logiciel sous linux ? >
Sous linux, les logiciels s'installent soit en recompilant les sources, soit à l'aide d'un système de packages (.deb, .rpm, etc) dans lesquels les programmes sont deja compilés pour une distribution et une architecture donnée.\\

Il est recommandé d'installer les logiciels dans leur version packagée pour sa distribution propre, plutôt que par les sources. Les versions packagées s'intègrent mieux à une distribution donnée, tandis que les versions sources ont une fâcheuse tendance à s'installer dans des répertoires locaux tels que ''/usr/local/bin'' au lieu de ''/usr/bin'', et les fichiers de configuration dans ''/usr/local/etc'' au lieu de ''/etc''.\\

Autre avantage : le système de package intégré à chaque distribution permet de mettre à jour automatiquement et d'un seul coup l'intégralité des logiciels installés, y compris les couches système de la distribution elle-même. Au contraire d'une installation par source qui exige de tout faire à la main pour mettre à jour chaque logiciel : télécharger les sources, les configurer, les compiler, les réinstaller...

L'installation par les sources est nécessaire dans 2 cas de figure :
  * besoin d'une option de compilation spécifique, qui n'est pas prévue dans la version packagée (souvent pour ajouter une fonctionalité non présente par défaut)
  * l'application n'existe pas dans un format de package pour sa distribution et n'est disponible que sous forme de sources.

NB; pour Debian : certains logiciels ne sont disponibles que en .rpm, mais cela n'empêche pas pour autant de les installer sous Debian (format .deb). Il existe dans ce but un outil de conversion .rpm --> .deb appelé alien. Pour installer un RPM procéder comme suit :
<code>
alien -d archive.rpm
dpkg -i archive.deb
</code>
Alien permet également de convertir d'autres format de packages : LSB, Stampede et Slackware.
</hidden>

<hidden Où trouver / télécharger des logiciels pour linux ? >
Bien sûr sur le site des éditeurs ;) Mais une question subsiste néanmoins : comment connaître les noms des logiciels pour linux ? Il existe à ce sujet plusieurs listes connues, dont les principales sont reprises dans les liens ci-dessous.\\

Equivalence logicielle :
  * http://gilo.idealx.com/
  * http://www.linux-nantes.fr.eu.org/DO...gicielles.html
  * http://fr.wikipedia.org/wiki/Alternatives_libres_aux_logiciels_propriétaires
  * http://www.linuxrsp.ru/win-lin-soft/table-eng.html

Liste d'applications :
  * http://www.sourceforge.net
  * http://www.freshmeat.org
  * http://www.framasoft.net
  * http://directory.fsf.org

Une autre chose à savoir : dans la plupart des cas, il est inutile d'aller sur le site de chaque éditeur télécharger une archive sur son disque dur, la décompresser et l'installer, comme on doit le faire sous Windows. C'était vrai par le passé sous linux, mais plus maintenant ! Chaque distribution propose son propre "gestionnaire de packages", logiciel qui va récupérer par internet la liste de toutes les applications précompilées disponibles pour votre distribution spécifique, et peut télécharger et installer automatiquement celles que vous désirez. Les versions sont bien entendu constamment à jour. Il est vivement conseillé de passer par ce logiciel pour chercher des logiciels (classés par catégories) et pour les installer en une seule opération.
</hidden>

<hidden Que représentent les fichiers .tar, .tar.gz, .tgz, .tar.bz2 ? >
Ces extensions représentent des archives de fichiers et répertoires (on parle parfois de "tarball"). Le format de fichier .tar permet d'archiver une arborescence de fichiers sans compression. Il est donc souvent couplé à ''.gz'' ou ''.bz2'', qui sont des formats de compression. \\

  * //Comment décompresser une archive ://
    * ''.tgz'' ou ''.tar.gz'' : 
<code>
$ tar -xzvf archive.tar.gz
</code>
    * ''tar.bz2'' : 
<code>
$ tar -xjvf archive.tar.bz2
</code>

  * //Comment créer une archive (remplacer x par c pour "create") ://
    * ''.tgz'' ou ''.tar.gz'' : 
<code>
$ tar -czvf archive.tar.gz monrepertoire/*
</code>
    * ''tar.bz2'' : 
<code>
tar -cjvf archive.tar.bz2 monrepertoire/*
</code>

Le "v" (verbose) est optionnel, mais il est utile car il indique en détails tous les fichiers traités et la progression de la (dé)compression.
</hidden>

<hidden Comment installer à partir des sources / comment compiler ? >
Pour installer un programme à partir des sources, il faut d'abord décompresser l'archive. Ensuite la compilation peut s'effectuer de différentes façons. La plupart du temps, il suffit de faire (en root) :
<code>
$ ./configure && make && make install
</code>
Mais pas toujours ! C'est pourquoi il est fortement conseillé de lire les fichier //README// et //INSTALL// (ou leurs équivalents).
</hidden>

<hidden Comment installer des packages RPM (Red Hat / Mandrake / SuSE / Fedora ...) ? >
Le RPM (ou Red hat Package Manager) est, comme son nom l'indique, un format propre à la distribution Red Hat (ou Fedora), aussi utilisé par Mandrake, SuSE et d'autres
Installer un package :
<code>
$ rpm -ivh nom_du_package
</code>                      
  * l'option -i installe le programme
  * l'option -v rend l'installation bavarde
  * l'option -h affiche une barre de progression (pour occuper vos yeux pendant l'install)

Et en cas de doute, ne pas hésiter à taper :
<code>
$ man rpm
</code>
</hidden>

<hidden Comment installer des packages deb (Debian / knoppix ...) ? > 
Installer un package deb implique de disposer d'un fichier packagename.deb (qu'on a téléchargé soi-même) et de l'installer avec :
<code>
dpkg -i filename.deb
<code>
Cette méthode est cependant très rarement utilisée, car il est rare qu'on doive travailler manuellement sur les packages sous Debian. Utilisez plutôt l'utilitaire apt-get qui peut télécharger et installer automatiquement une application complète avec tous les packages dont elle dépend.
</hidden>

<hidden Le cd-rom ne démarre pas. Comment installer ? >
Vous devez disposer de deux disquettes et... d'un ordinateur (avec windows ou linux), pour faire des copies de fichiers sur les disquettes. \\

La première étape est la création de la disquette boot. Cette disquette permet de préparer le système et charger linux. Il vous faut donc choisir l'image selon votre matériel (choix surtout selon le type de lecteur CD-ROM et de disques durs). Vous trouverez les images sur le CD de votre distribution (répertoire ''/bootdisks''). Si vous avez un disque dur IDE et que votre lecteur CD-ROM n'est pas exotique, utilisez l'image nommé bare (lire le fichier //README// sinon). Sous windows, exécutez le programme rawrite (présent dans le même repertoire que l'image) puis spécifier l'image et le lecteur de destination (lecteur de disquette dans notre cas). Sous linux, utilisez la commande dd pour copier l'image.\\

La seconde étape est la création de la disquette root. Cette disquette contient les fichiers nécessaires pour exécuter les commandes linux. Vous devrez procéder de la même facon que pour la disquette boot et choisir un fichier image (répertoire ''/rootdisks''). Probablement, le fichier ''color.gz'' conviendra (sinon lire le ''README''). \\

Vos deux disquettes sont créées. Insérez la disquette boot dans le lecteur de disquette puis relancez votre ordinateur. L'ordinateur chargera linux puis affichera :
<code>
boot:
</code>
Appuyer sur la touche entrée pour poursuivre. Le chargement se poursuit (profitez-en pour vérifier que linux a bien reconnu votre lecteur CD-ROM ; si ce n'est pas le cas, vous devrez changer de fichiers images). Ensuite un message équivalent sera affiché :
<code>
VFS: Insert ramdisk floppy and press ENTER
</code>
Retirez la disquette boot et insérez la disquette root. Linux charge un petit système de fichier en mémoire avec les commandes linux importantes (comme fdisk).
Vous pouvez installer linux à partir du CD-ROM maintenant si tout s'est bien passé (commande setup sous slackware par exemple).
</hidden>

<hidden Comment sont représentés les périphériques (disques durs, lecteur DVD/CD-ROM, etc.) ? >
Chaque périphérique est représenté par un fichier dans le répertoire ''/dev/''. Le nom du disque dur dépend de son type. Les disques (disques durs, lecteur DVD/CD-ROM) IDE et EIDE ont pour nom /dev/hda pour le premier disque (primary master), /dev/hdb pour le second (primary slave), etc. Les disques SCSI sont eux appelés ''/dev/sda'', ''/dev/sdb'', etc. Les partitions des disques durs sont traités comme des unités séparées. La première partition sur le premier disque IDE est appelée ''/dev/hda1'', la deuxiéme ''/dev/hda2'', etc. (de même pour les autres disques durs).  Pour lister les partitions présentes sur un disque dur, exécutez :
<code>
# fdisk -l /dev/hda
</code>
</hidden>

<hidden Comment partitionner et formater un disque dur ? >
Pour partitionner, on peut utiliser les outils fdisk, cfdisk ou encore ''parted/qparted''. ''fdisk'' est le plus "rugueux" des 3, il est en mode ligne de commande spartiate, pas très convivial. ''cfdisk'' est une version plus pratique à utiliser avec des menus en mode console, c'était cette solution qui était utilisée auparavant dans l'installation de linux Debian.
Parted, et son équivalent en mode graphique QParted (sous KDE), est un programme qui est pareil à PartitionMagic connu sous Windows. Ce genre de programme permet non seulement de partitionner un disque, mais aussi de redimensionner et fusionner des partitions sans perte de données (en principe ! mieux vaut faire des sauvegardes quand même, quelque soit le logiciel d'ailleurs), ce qui en fait tout leur intérêt. \\

Le formatage utilise quant à lui des programmes comme ''mkdosfs'', ''mkfs'', ce dernier étant un programme générique décliné en plusieurs versions suivant le format désiré : ''mkfs.ext2'', ''mkfs.ext3'', ''mkfs.reiserfs'', etc. \\

Pour formater la partition hda5 en ext3 :
<code>
mkfs.ext3 /dev/hda5
</code>

Pour formater en FAT32 c'est un peu plus compliqué :
<code>
mkdosfs -F 32 -n c: -v /dev/hdx
</code>
  * ''-F 32'' pour désigner le système de fichiers fat32
  * ''-n c'': c'est le nom de la partition que l'on veut formater
  * ''-v'' active le mode verbos
  * ''/dev/hdx'' désigne la partition à formater

</hidden>

<hidden Pourquoi partitionner et comment ? >
Le partitionnement est intimement lié au filesystem (hors Logical Volume Manager et encore ! ) Un système Linux (unix) se présente sous forme d'une arborescence de repertoire dont certain sont ou peuvent être des filesystem different donc des partitions un partionnement minimal est :
  * un swap
  * un 'root' (repertoire racine principal) \\

La manière de déterminer la dimension d'un swap peut varié d'un auteur à un autre, toutefois une base consensuel peut être donnée : 
  * si RAM <= 512 Mo Taille du swap = 2 fois la RAM
  * si RAM > 512 Mo Taille du swap = RAM\\

Des besoins particuliers peuvent nécéssité une taille de swap supèrieure : Pas de possibilité d'ajouter de la RAM, ou application(s) trés gourmandes en ressources non lancée en permanence. Des qu'un besoin de swap supèrieure à 1 Go devient nécéssaire, il est utile de penser à créer 2 (ou plus) zones de swap et si possible sur un 2eme disques ceci pour au moins deux raisons :
  * répartition des accés disques 
  *  possibilité de detruire/modifier le 2eme swap sans reboot\\

Les commandes liés au swap sont : 
  * mkswap devices 
  *  swapon fichierswap
  * swapoff fichierswap\\

Attention la première zone de swap nécéssite un reboot immédiat. \\

Pour les autres partitions il convient avant tous de détèrminer l'usage de la machine. Les outils de sauvegarde tel ''backup/restore'' peuvent travailler par filesystem (donc partition pour rester simple), il offre l'intérrés de pouvoir faire des sauvegardes différentiels (uniquement les changement depuis la dernière sauvegarde) faut il encore que le support de la sauvegarde ai la capacité en volume de le supporter (sauvegarder 10 Go sur un CD ou une Clef USB, sa passe pas). La taille des filesystems va donc être influancées par le média de sauvegarde autant que par ce que l'on va y stocker dessus. Pour ces raisons je préconnise un filesystem (donc une partition) par type (ou provenance) de données. Leurs tailles respectives ne pouvant être évaluées qu'en fonction d'élément propre à chaque configuration.

La partition contenant le filesystem 'root' (/) depend en grande partie de la distribution utilsée, en effet d'une distribution à l'autre l'espace nécéssaire à l'installation varie (voir la doc de la distribution).  Cette taille varie de environ 1 Go à 5 Go celons la distribution et le choix de paquetage. (Pour des installations rapides est standards avec les choix par defaut). La partition ''/filesystem'' ''/boot'' couremment créer par un certain nombre d'entre elle est plus "historique" que nécéssaire ; cette implementation date de l'époque ou lilo (le boot loader) ne savait pas booter au dela d'une certaine valeur (me rappelle plus) de cylindre du disque dur. \\

Deux repertoire standard, ''/tmp'' et ''/var'', mérite une attention particulière. ''/tmp'' est le repertoire temporaire, et est utilisé par la plupart des softs, y compris système, pour y stocker de manière temporaire des données liées à ceux-ci. Une taille restreinte est suffisante ( environ 500 Mo). ''/var'' est le repertoire ou sont stockées tout aussi bien certaine données temporaire (spooler d'impression, mail en attente d'expedition ou lecture, ...) que les fichiers logs du système et (normalement) de toutes applications.
La taille de cette espace depend donc aussi de l'usage de la machine ainsi que de la fréquence de nettoyage des logs. Hors serveur de mail, d'impression, samba une taille de 1 Go est suffisante. \\

Reste, ... le reste dont le repertoire ''/home'' et ''/usr/local'' (et parfois ''/opt''). ''/home'', celui-ci est le repertoire standard de connection des utilisateurs. Il contient , outre l'environnement de chaque utilisateur, des données comme : mails, bookmark. Si vos utilisateurs disposent de repertoires sur serveur (y compris local), la Taille reste restreinte (attention au volume mail). ''/usr/local'', ce repertoire devrait être utilisé pour toute installation de soft ne provenant pas de la distribution. L'interêt que ce soit un filesytem different est tout simplement qu'une mise à jour de votre system ne touche pas à celui-ci ! Sa taille depend donc de ce que vous aller installer hors distribution.\\

Ensuite un filesystem par usage est une bonne choses, par exemple :
  * ''/data_sql'' pour une base de donnée (eventuellement ''/data_sql1'', ....).
  * ''/bureautique'' pour les données bureautique (vous l'aviez deviné non ?).
  * ''/musique'' pour couvrir le bruit de la climatisation
  * ''/bidouille'', il n'y a que comme cela que l'on avance.
  * etc .... \\

Pour conclure, un bon debut est :
  * 1 à 5 Go ==> / 500 Mo ==> /tmp 1 Go ==> /var RAM (X2) ==> swap 1 Go à ? ==> /usr/local 1 Go à ? ==> /home .....

**Attention :**  
  * La partition contenant / ne doit pas être etendue (ou /boot quand elle existe).
  * Un system Intel ne supporte pas de plus de 4 partitions principales par disque \\

fdisk devices est l'outils de partitionnage
mkfs -t type_de_filesystem devices est la commande de création de filesystem (sauf pour le swap)
ne pas oublier de mettre à jour le fichier /etc/fstab afin d'avoir ses filesystems monté lors du boot
</hidden>


===== Configuration Matériel =====

<hidden  Comment installer les drivers Nvidia ? > 
  * 1. Télécharger le driver sur le site de nvidia 
  * 2. Il faut quitter le mode graphique pour l'installation :
<code>
$ init 3
</code>
  * 3. Installation du driver :
<code>
$ sh /ou_tu_as_mi_le_fichier/NVIDIA-Linux-x86-xxxxx.run
</code>
  * 4. Il faut dire à XFree d'utiliser le nouveau driver :
<code>
$ vi /etc/X11/XF86Config-4
</code>
On a quelque chose qui ressemble à ça :
<code>
Section "Device"
    Identifier "device1"
    VendorName "nVidia Corporation"
    BoardName "RIVA TNT2"
    Driver "nv"
    Option "DPMS"
EndSection
</code>
Remplacer "nv" par "nvidia".
  * 5. On relance l'interface graphique et on admire le logo nvidia au démarrage :
<code>
$ init 5
</code>
  6. On peut tester l'accélération 3D en jouant à tuxracer par exemple... Si ça ne saccade par ENORMEMENT, c'est gagné !
</hidden>

<hidden Comment configurer mon serveur XFree 4 ? >
Vous avez plusieurs choix possibles :
  - utiliser l'outil de configuration xf86config (répondre aux questions posées)
  - utiliser une distribution liveCD comme la knoppix puis récupérer le fichier de configuration du serveur X (copier le sur une disquette, le disque dur,...)
  - utiliser la configuration automatique.

Pour la configuration automatisée, exécutez :
<code>
$ X -configure
</code>
Cette commande crée un fichier de configuration nommé ''XF86Config'' dans le répertoire ''/root''. Editez le fichier de configuration :
<code>
Section "Screen"
    Identifier "Screen0"
    Device "Card 0"
    DefaultDepth 24   # Ligne à rajouter
    ....
    SubSection "Display"
        Depth 24
        Modes "1280x1024" "800x600"   # Ligne à rajouter
    EndSubSection
EndSection
</code>
Copiez le fichier:
<code>
$ cp /root/XF86Config /etc/X11/
</code>
</hidden>

<hidden Comment configurer ma souris ?  >
Si votre souris ne fonctionne pas, vous avez plusieurs possibilités : 
  - Refaire la configuration du début avec un utilitaire comme xf86config
  - Modifier le fichier de configuration du serveur X

Le problème avec la souris peut provenir d'un mauvais choix de protocole ou de device. Voici une partie d'un fichier type ''XF86Config'' ou ''XF86Config-4'' (''/etc/X11'') :
<code>
Section "Server Layout"
        ...
        InputDevice "Ma souris" "CorePointer"
        ...
EndSection

Section "InputDevice"
       Identifier "Ma souris"
       Driver "mouse"
       Option "Protocol" "ImPS/2"
       Option "ZAxisMapping" "4 5"  # Pour le fonctionnement de la molette
       Option "Device" "/dev/mouse"
EndSection
<code>

Si vous possédez une souris classique, le protocole ''ImPS/2'' conviendra parfaitement. \\
  
En ce qui concerne l'option "Device", l'élément "/dev/mouse" lui a été affecté. Ce lien dépend du type de la souris :
  * PS/2 : ''/dev/psaux'' (''ln -s /dev/psaux /dev/mouse'')
  * USB : ''/dev/input/mice'' (''ln -s /dev/input/mice /dev/mouse'')
  * COM : ''/dev/ttyS0'' (si la souris est sur le premier port COM)

NB : il se peut que vous deviez charger des modules du noyau pour son bon fonctionnement (par exemple les modules USB pour une souris USB).
</hidden>

<hidden Comment configurer sa carte réseau ? > 
Si vous possédez une carte réseau de type Ethernet (ce qui est probablement le cas), vous devez obligatoirement avoir ethX en plus de lo (interface de loopback) dans la liste des interfaces réseau disponibles (pour la voir tapez ifconfig en root). Si ce n'est pas le cas, votre carte n'est pas reconnue... ou est démontée :
<code>
$ ifconfig ethX up
</code>
pour la remonter. \\

Si la carte n'est pas reconnue, il faudra charger le module approprié du noyau. Les modules les plus courants actuellement sont 8139too (chipset Realtek) et via-rhine (cartes D-Link par ex). 
<code>
root@orion /home/francois # ifconfig
eth0      Lien encap:Ethernet  HWaddr XX:XX:XX:XX:XX:XX
          inet adr:192.168.0.32  Bcast:192.168.0.255  Masque:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1035 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1170 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:100
          RX bytes:580187 (566.5 Kb)  TX bytes:319752 (312.2 Kb)
          Interruption:10 Adresse de base:0xf800

lo        Lien encap:Boucle locale
          inet adr:127.0.0.1  Masque:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:74 errors:0 dropped:0 overruns:0 frame:0
          TX packets:74 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:0
          RX bytes:4306 (4.2 Kb)  TX bytes:4306 (4.2 Kb)
</code>
Pour spécifier une adresse ip, il suffit de taper :
<code>
$ ifconfig ethX X.X.X.X
</code>
X.X.X.X correspondant à l'adresse ip et X de ethX correspondant au numéro de votre carte Ethernet. \\

Si vous désirez retirer une éventuelle adresse ip (dans le but par exemple de négocier une connexion pppoe), tapez simplement :
<code>
$ ifconfig ethX 0.0.0.0
</code>

Pour configurer la passerelle (gateway) de votre réseau, utilisez la commande route comme suit :
<code>
$ route add -net 0.0.0.0 netmask 0.0.0.0 gw 192.168.0.1 dev eth0
</code>
La commande route -n affiche la table de routage complète, ce qui nous permet de vérifier la configuration :
<code>
Kernel IP routing table
	Destination  Gateway      Genmask      Flags Metric Ref Use Iface
	192.168.0.0  *            255.255.0.0  U     0      0     0 eth0
	0.0.0.0      0.0.0.0      0.0.0.0      UG    0      0     0 eth0
</code>
Indiquez ensuite vos serveurs de résolution de nom (DNS) dans le fichier ''/etc/resolv.conf'' :
<code>
nameserver x.x.x.x
nameserver y.y.y.y
</code>
Les adresses des DNS sont fournis par votre administrateur réseau ou par votre FAI. \\

Ceci est la méthode générique, cependant la configuration réseau est très souvent reprise dans un script ou un fichier de configuration dont la syntaxe est propre à chaque distribution, et qui sera lu/exécuté au démarrage de la machine. De plus les distributions offrent la plupart du temps des assistants de configuration, que ce soit en console ou en mode graphique.
</hidden>

<hidden Comment changer le débit de sa carte réseau ?  >
Vérifiez si vous avez la commande mii-tool (commande root). Si vous n'avez pas la commande, installez-la (package net-tools). \\

Exemple pour forcer l'utilisation de sa carte en 100Mbit, full Duplex :
<code>
$ mii-tool eth0 -F 100baseTx-FD
</code>
Les possibilités sont :100baseT4, 100baseTx-FD,100baseTx-HD, 10baseT-FD, ou 10baseT-HD. La modification est immédiate et persistante.
</hidden>

<hidden Comment activer le numlock automatiquement ?  >
Avec le serveur X :
  * Télécharger le programme numlockx et l'installer.
  * Activer le numlock :
<code>
$ numlockx on
</code>
  - Désactiver le numlock :
<code>
$ numlockx off
</code>
Pour que ce soit automatique, il faut ajouter la ligne suivante au fichier .xinitrc ou .xsession avant le lancement du window manager :
<code>
$ numlockx &
</code>

Sans le serveur X :
  * Sur la gentoo il y a un script d'initialisation qui le valide sur toutes les consoles :
<code>
$ /etc/init.d/numlock start
</code>
Et pour que ce soit automatique au démarrage :
<code>
$ rc-update add numlock default
</code>
  * Sous Debian pour la console, il y a un fichier de configuration /etc/console-tools/config dans lequel il faut aller décommenter/ajouter la ligne suivante (dernière ligne du fichier) :
<code>
LEDS=+num
</code>
</hidden>

<hidden Comment configurer une imprimante ? >
Aujourd'hui, la gestion des imprimantes passe par le programme [[http://www.cups.org/|CUPS]]. Une fois installé, le démon offre une interface web sur le port 631, il suffit donc de visiter l'url http://localhost:631 en mode graphique pour avoir accès à la configuration. Il est assez aisé d'ajouter une imprimante.\\

Pour savoir si votre imprimante est bien supportée, ou pour télécharger le fichier PPD approprié à indiquer à CUPS pour dialoguer avec votre imprimante, visitez le site [[http://www.linuxprinting.org/|linuxprinting.org]].
</hidden>

<hidden Comment installer un scanner ? >
La gestion des scanners sous linux passe par le programme [[http://www.sane-project.org/|SANE]] qui supporte la plupart des scanners modernes. Si votre scanner est USB, veillez à ce que le module approprié soit chargé, ce qui est le cas sur les noyaux fournis par défaut avec les distributions actuelles. Il vous suffira donc d'installer sane, et son front-end graphique xsane qui vous permettra de paramétrer le scanner et numériser directement. Attention, vous devrez veiller à inclure vos utilisateurs dans le groupe système "scanner" (adduser toto scanner) sans quoi l'accès au scanner leur sera refusé. Certaines applications graphiques comme Gimp peuvent faire appel à sane de manière intrinsèque pour acquérir une image.
</hidden>

<hidden Comment voir si l'hyperthreading est actif ? >
Quand l'hyperthreading est actif sous Linux, le noyau voit deux CPUs logiques au lieu d'un (visible dans /etc/cpuinfo). Comment distinguer alors les CPUs physique et logique  ?Très simplement, en regardant le physical id du CPU !  Dans votre /proc/cpuinfo, vous observez ceci
</code>
processor 0
physical id     : 0

processor 1
physical id     : 0

processor 2
physical id     : 3

processor 3
physical id     : 3
</code>

Cela signifie que vous avez deux CPUs physiques mais quatre logiques! L'hyperthreading est actif 
Sinon, vous auriez :
<code>
processor 0
physical id     : 0

processor 1
physical id     : 3
</code>
</hidden>

<hidden Comment 'émuler' un driver windows avec ndiswrapper ? >
Voici une méthode à appliquer si vous souhaitez faire un driver avec ndiswrapper : 
  * trouver la référence exacte du chipset
  * une fois qu'on est certain qu'il n'existe pas de driver natif pour Linux, allez chercher le driver windows (un fichier *.inf)
  * vérifiez que le module ndiswrapper est chargé dans le noyau
<code>
$ lsmod|grep ndiswrapper
</code>
  * si ce n'est pas le cas, chargez-le avec modprobe, et configurer votre système pour le charger au démarrage :
<code>
$ modprobe -r ndiswrapper
$ echo ndiswrapper >> /etc/modules
</code>
  * installez le driver
<code>
$ ndiswrapper -i driver.inf
</code>
  * vérifiez que c'est installé, et qu'il a repéré le matériel
<code>
$ ndiswrapper -l
driver installed ... hardware detected
</code>
  * si un mauvais driver était déjà installé, supprimez-le
<code>
$ ndiswrapper -e driver
$ rm -rf /etc/ndiswrapper/driver
</code>
</hidden>

<hidden Comment remplacer un disque défectueux en RAID-1 ? >
Nous partons de l'exemple d'un serveur en production avec un système de RAID-1 logiciel sous linux géré par mdadm. Il y a donc 2 disques durs identiques en mode miroir : tout ce qui est écrit sur un disque est cloné sur le 2e disque. Tout le système a été placé dès l'installation sur une seule partition RAID /dev/md0, et on a un petit swap sur chaque disque (en sda2 et sdb2, ce sont des disques SATA). Donc sda1 = partition raid (formatée en ext3, reiserfs ou autre), sda2 et sdb2 = swap.\\

  * 1. Débrancher câble réseau (évite l'utilisation du serveur pendant la maintenance). A noter que techniquement tout peut être fait à chaud au niveau logiciel, et même pour (dé)brancher les disques si le hardware est prévu pour (SATA / baies hotswap). Néanmoins, comme certains reboots de test sont conseillés, il vaut mieux débrancher pour être tranquille.

  * 2. Serveur allumé dans l'état actuel, on retire au niveau logiciel le disque défectueux de l'array RAID :
<code>
$ mdadm /dev/md0 -r /dev/sda1
</code>

  * 3. Rendre sdb1 bootable avec cfdisk, et installer le MBR Grub sur sdb avec les commandes suivantes dans le prompt de grub (taper grub pour y accéder) :
<code>
device (hd0) /dev/sdb
root (hd0,0)
setup (hd0)
</code>

  * 4. Rebooter, modifier le BIOS pour lui dire de booter sur le disque 2 (sdb), et tester que tout démarre normalement. Sinon Knoppix et chroot pour résoudre le problème.\\

  * 5. Remplacer le disque dur défectueux (si hotswap ou même SATA en théorie, pas besoin d'éteindre la machine). \\

  * 6. Partitionner le disque en 2 partitions de tailles exactement identiques à l'installation originale(cfdisk) :
    * sda1 : type FD = "Linux raid autodetect"
    * sda2 : type 82 = "Linux swap"
Créer la swap : 
<code>
$ mkswap /dev/sda2
</code>

  * 7. Remonter le raid :
<code>
$ mdadm /dev/md0 -a /dev/sda1
</code>

  * 8. La reconstruction démarre aussitôt automatiquement, on peut surveiller la progression en tapant ''cat /proc/mdstat'' périodiquement. Pendant la reconstruction, rebrancher le câble réseau pour que le serveur soit à nouveau utilisable. A la fin, un message l'indique sur la console locale. Vérifier que les 2 disques sont bien utilisés avec ''cat /proc/mdstat'' le code UU doit apparaître à la fin.

  * 9. Réinstaller Grub aussi sur le nouveau disque (+ changer boot BIOS sur disque 1) :
<code>
device (hd0) /dev/sda
root (hd0,0)
setup (hd0)
</code>

  * 10. Une fois que c'est fini, rebooter une dernière fois pour être sûr que tout est ok.\\

Toute l'opération décrite a été réalisée telle quelle par mes soins lors d'une intervention réelle sur un serveur mail en production dans un réseau d'une quarantaine de personnes.
</hidden>


===== Le Shell =====

<hidden Pourquoi est-il important de maîtriser la ligne de commande sous linux ? >
Contrairement à Windows, linux peut être entièrement piloté en ligne de commande, par laquelle on a accès à toute sa puissance et toute sa configuration. L'interface graphique n'est qu'une couche applicative optionnelle, mais non nécessaire pour des serveurs par exemple (qui ne font basiquement que répondre à des requêtes réseau). Un administrateur système se doit de maîtriser le shell pour diverses raisons :
  * même si certaines distributions ou applications proposent des assistants de configuration graphiques, c'est en modifiant les fichiers de configuration textuels qu'on arrive à paramétrer le plus finement le système
  * le shell et son langage sont très puissants et bien souvent il est très efficace de réaliser quelques scripts simples pour automatiser certains traitements sur des serveurs, ou modifier des configurations de services à la volée
  * par sécurité on évite d'installer tout élément non strictement nécessaire sur un serveur (exemple typique : une interface graphique), et son administration à distance se fera la plupart du temps en ssh, qui est un protocole d'accès sécurisé à la console par le réseau.
  * la maîtrise du shell permet de contrôler le système à 100% (surveillance complète de l'activité de la machine, démarrage et arrêt d'applications, gestion du multitâches, recherches rapides, etc.), et est donc un moyen très efficace d'administrer une machine\\

Une autre raison est que sous linux toute la configuration est transparente, stockée dans des fichiers textuels lisibles par tous et généralement bien documentés (commentaires). La configuration de pratiquement n'importe quel logiciel peut donc s'effectuer par un simple éditeur de texte, ou à l'aide de scripts où le langage Perl est assez populaire puisqu'il est spécialement dédié au traitement de chaînes de caractères.\\

Même pour une utilisation de linux en tant que station de travail où des assistants graphiques vous facilitent les tâches courantes (configuration de base, installation de logiciels, etc.), un minimum de notions de shell s'avéreront nécessaires dès que vous devrez vous plonger dans certaines configurations un peu plus complexes comme par exemple la modification des paramètres noyau, ou autres éléments système.
</hidden>

<hidden Comment fonctionne le shell ? >
Le shell est un interpréteur de commande en mode texte (ou console). Il permet de passer des ordres (commandes) au système, et de "dialoguer" avec lui (on parle de shell interactif). Il est possible de piloter entièrement linux en ligne de commande : démarrer, suspendre et arrêter des programmes, gérer les services (programmes résidents en mémoire), configurer le système (édition de fichiers texte), gérer les tâches planifiées, le multi-tâches, etc.\\

Une des premières choses à apprendre sous linux est le shell et ses commandes de base, car cela permet d'avoir une totale maîtrise du système.\\

Techniquement, le shell est une boucle infinie en C qui lit ce que l'utilisateur tape au clavier et réagit :
  * soit il s'agit d'une commande interne du shell qui est exécutée directement (fonction interne, ou builtin)
  * soit il lance un programme externe
  * il doit aussi interpréter les caractères spéciaux (redirection, pipes, etc.)
</hidden>


==== Les commandes de bases ====

<hidden Comment exécuter un programme ? >
Pour exécuter un programme, il faut dans un premier temps que celui-ci possède le format adéquat (elf) et puisse être exécuté sur son architecture (i386, mips, sparc, etc). Vous pouvez vérifier cela avec la commande file :
<code>
$ file nom_du_programme
</code>
Ensuite il faut que le fichier possède les droits en exécution pour vous.
<code>
$ chmod +x programme
</code>
Il ne vous reste plus qu'à l'exécuter en spécifiant le chemin absolu du fichier :
<code>
$ /usr/local/bin/xmms
</code>
Cela est assez fastidieux. Pour résoudre ce problème, il suffit de rajouter dans la variable PATH de votre shell le chemin de l'exécutable. Pour le shell sh/Bash :
<code>
$ export PATH="${PATH}:/usr/local/bin"
</code>
Pour les shells csh, tcsh :
<code>
$ setenv PATH "${PATH}:/usr/local/bin"
</code>
</hidden>

<hidden Comment lister les variables d'environnement ? >
Sans option, la commande export affiche la liste des variables d'environnement -- tandis que, toujours sans option, la commande set, et en moins exhaustive mais fonctionnant avec tous les shells la commande env, affichent la liste des variables locales :
<code>
$ export
(...)
declare -x HOME="/u/moi"
declare -x PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin"
declare -x LOGNAME="moi"
declare -x SHELL="/bin/bash"
declare -x MAIL="/mail/moi/inbox"
declare -x USER="moi"
declare -x HOSTNAME="moi.exemple"
(...)
$ set  # ou env
(...)
HOME=/u/moi
HOSTNAME=moi.exemple
HOSTTYPE=i686
IFS=$' \t\n'
INPUTRC=/etc/inputrc
LD_LIBRARY_PATH=/usr/local/lib
MAIL=/mail/moi/inbox
(...)
</code>
</hidden>

<hidden Comment écrire un script shell simple ? >
Ouvrez votre éditeur de texte et tapez les différentes commandes que le script exécutera :
<code>
#!/bin/sh
echo "lancement d'un script simple.."
# on lance mozilla
mozilla&
</code>
La ligne ''#!/bin/sh'' (ou shebang line) est une convention. Cela signifie que l'interpréteur de commande sera le Bourne Shell (sh). Si rien n'est précisé il prendra le shell par défaut de l'utilisateur. Attention à pas confondre avec une ligne en commentaire (# ceci est un commentaire). \\

Pour exécuter le script vous devrez au préalable appliquer les permissions nécessaires :
<code>
$ chmod +x nomduscript.sh
$ ./nomduscript.sh
</code>
</hidden>

<hidden Comment ajouter des alias ? >
<code>
$ alias ll='ls -l'
</code>
Grâce à cet alias, lorsque vous taperez
<code>
$ ll
</code>
dans votre terminal, cela exécutera la commande
<code>
$ ls -l
</code>
Pour voir la liste des alias activés, vous pouvez taper :
<code>
$ alias
</code>
</hidden>

<hidden Comment modifier un fichier en mode console ?  >
Il existe plusieurs éditeurs de texte en console, mais le plus répandu est sans doute vi. Quelle que soit votre distribution, vous êtes sûr de pouvoir compter sur lui. Utilisation :
<code>
$ vi fichier
</code>
Pour modifier le texte, appuyer sur "a" (curseur placé avant la lettre), "i" ou INSERT(curseur placé après). Une fois les modifications faites, appuyer sur ESCAPE, ensuite on donne les commandes à exécuter en tapant ":" (deux points) suivi de la lettre qui correspond à la commande :
  * :w pour sauver les modification
  * :q pour quitter
  * :wq pour sauver et quitter.

En résumé, vi est simple et très complet. Noter qu'il existe aussi vim (pour vi improved), avec l'ajout notamment de la coloration syntaxique, et aussi gvim, en mode graphique... \\

Malheureusement les éditeurs les plus "classiques" et "puristes" sous linux sont aussi les plus complexes à utiliser, et sont fort déroutants pour les débutants. Je vous rassure il existe des éditeurs nettement plus simples comme nano ou pico (fort semblables), qui s'utilisent avec les touches normales et intuitives (flèches du clavier, touches home et end, etc.). En gros l'utilisation de nano est très simple :
<code>
$ nano monfichier.txt
</code>
Ouvre le fichier monfichier.txt pour l'éditer, "nano" tout court va créer un nouveau fichier. \\

Dans le programme, Ctrl+W (w pour "write") permet de sauver le fichier, et Ctrl+X quitte le programme (en vous demandant s'il faut enregistrer les modifications le cas échéant). \\

Une autre alternative appréciée de bien des gens est le programme mc (midnight comander), le couteau suisse en mode console de linux, équivalent au norton commander de l'époque héroïque du DOS. Ce programme regroupe donc un gestionnaire de fichier (avec la vue à 2 panneaux classique), un éditeur de texte, des utilitaires de recherches, de copie de fichiers, etc.\\
</hidden>

<hidden Comment rajouter la coloration syntaxique dans vim ? >
Pour rajouter la coloration syntaxique
<code>
vi /etc/vim/vimrc
</code>
enlever le " devant
<code>
" syntax on
</code>
Il est tout de même préférable d'utiliser le fichier ~/.vimrc pour rajouter la coloration syntaxique. En effet le fichier /etc/vim/vimrc impacte tous les utilisateurs.
</hidden>

<hidden Comment ouvrir une autre console ? >
  * En mode console : Alt+F1, Alt+F2 etc. où le chiffre représente la console désirée (il y en a 4 disponibles par défaut). 
  * En mode graphique, tapez dans un shell :
<code>
$ xterm &
</code>
</hidden>

<hidden Connaître le type d'un fichier  >
La commande file vous renseigne sur le type et le format d'un fichier :
<code>
$ file code.c
code.c: ASCII C program text
$ file file.png
file.png: PNG image data, 1014 x 704, 16-bit/color RGB, non-interlaced
</code>
</hidden>

<hidden Comment afficher/concaténer des fichiers ? >
La commande cat permet d'afficher le contenu d'un ou plusieurs fichiers (à la suite dans le second cas) :
<code>
$ cat fichier1
contenu du fichier1
$ cat fichier2
contenu du fichier2
$ cat fichier3
contenu du fichier3
$ cat fichier1 fichier2 fichier3
contenu du fichier1
contenu du fichier2
contenu du fichier3
</code>
</hidden>

<hidden Comment connaître le temps d'exécution d'une commande ? >
Exécutez le programme time avec la commande pour argument :
<code>
$ time commande 
real 0m15.953s 
user 0m14.500s 
sys 0m1.320s
</code>
Les trois valeurs sont :
  * real : temps total qui s'est écoulé
  * user : temps du CPU qui s'est écoulé en user mode
  * sys : temps du CPU qui s'est écoulé en kernel mode

Il faut savoir qu'un processus s'exécute dans plusieurs modes : user mode ou kernel mode. Le changement de mode s'effectue lorsque le processus utilise des appels système. Ce sont des fonctions dans les programmes pour accéder à des fonctionnalités du noyau (comme écrire sur un terminal, ouvrir un fichier, etc). C'est ce que représentent les valeurs user et sys. Vous devez maintenant vous poser la question suivante : l'addition des temps du user mode et du kernel mode ne me donne pas la valeur du temps total d'exécution. Pourquoi ? C'est très simple : un système d'exploitation ne fait pas tourner en temps réel tous les processus (vous n'avez qu'un processeur). Il doit jongler entre les processus (on nomme cela un scheduler). Mais il fait cela tellement vite que vous avez l'impression que vos processus tournent en parallèle. Vous avez donc compris que le temps total qui s'est écoulé représente : le temps d'exécution de votre processus + celui des autres processus qui se sont écoulés dans le même temps.

</hidden>

<hidden Quels raccourcis bash pour gérer mes commandes? >
La plupart des gens connaissent les rappels de commandes avec bash en utilisant, simplement,les touches "flèche haut" et "flèche bas". Mais il existe une serie de rappels moins utilisés, plus ou moins connues :
<code>
!! : relance la derniere commande utilisé 
!32 : relance la commande 32 de l'historique ( history pour lire l'historique ) 
!ls : relance la derniere commande de l'historique qui commence par ls 
!-2 : relance l'avant derniere commande 
!!s:/ls /ls -l/ : relance la derniere commande en modifiant ls par ls -l [/list][/list]
</code>
</hidden>

<hidden Qui est connecté à cette machine? >
Quand vous avez beaucoup d'utilisateurs sur votre linux, il est interressant de savoir qui est présent et quelle est son activité.
La commande :
<code>
$ who
</code>
vous permet de savoir qui est connecté. Pour savoir s'ils sont actifs (utilisation du clavier), il vous suffit de faire un
<code>
$ finger nom_du_user 
</code>
Le temps "idle" correspond au temps entre la dernière pression du clavier et maintenant.
</hidden>

<hidden Comment envoyer un message à toutes les personnes connectés? >
La commande wall permet de lancer un message en broadcast à toutes les personnes connectées à votre machine via un terminal. Deux méthodes :
  * Soit vous écrivez un fichier et lancez :
<code>
$ wall mon_fichier
<code>
  * Soit vous lancez ''wall'', tapez votre message et terminez par CTRL+D
</hidden>

<hidden Comment enlever les Bips-Bips des consoles? >
Pour faire taire les bips de la console, chaque fois que vous appuyez sur tab, éditer le fichier /etc/inputrc et ajoutez juste la ligne :
<code>
set bell-style none
</code>
</hidden>

<hidden Quels sont les raccourcis claviers intéressants en ligne de commande ? >
  * C-b Recule d'un caractère (idem flèche à gauche)
  * C-f Avance d'un caractère (idem flèche à droite)
  * C-a Va en début de ligne
  * C-e Va en fin de ligne
  * C-p Reprend la commande précédente (idem flèche montante)
  * C-n Reprend la commande suivante (idem flèche descendante)
  * C-d Détruit le caractère
  * C-k Détruit le reste de la ligne
  * C-u efface la ligne
  * C = touche CTRL
</hidden>

<hidden Comment faire des opérations arithmétiques en shell ? > 
Bash ne sait pas travailler avec les nombres réels. Pour faire une opération avec des nombres relatifs, bash suffit
<code>
$ echo "3*2 = " $[ 3 * 2 ]
</code>
Pour toute opération avec des réels, il faut utiliser bc. Exemple : combien fait 5/2 ?
<code>
echo "5/2"|bc -l
</code>
''bc'' m'affiche 2.50000000000000000000, comment limiter le nombre de décimales ? Avec
<code>
echo "scale=1;(5/2)"|bc -l
</code>
affichera 2.5. 1 est le nombre de chiffres après la virgule.
</hidden


==== Commandes avancées ====

<hidden Comment connaître les différents processus en cours lancés par un programme ?>
Par exemple, vous utilisez le shell zsh, et vous voulez savoir à quel(s) PID (Processus IDentification) il(s) est(sont) lié(s).
La commande fuser retourne les différents PID de zsh :
<code>
$ fuser /bin/zsh
/bin/zsh: 1942e 2860e 2996e 3469m 3487e 4527m 4607e
</code>
Comme indiqué dans le man, les caractères suivant le PID correspondent à :
  * c : répertoire courant
  * e : programme en cours d'exécution
  * f : fichier ouvert. f est omis par défaut 
  * r : répertoire racine
  * m : fichier projeté en mémoire, ou bibliothèque partagée.
On observe donc ici que l'on a 5 programmes zsh en cours d'exécution, et 2 projetés en mémoire. On vérifie la valeur des PID qui correspond bien aux valeurs retournées par fuser :
<code>
$ ps -aux | grep zsh
francois 1942 0.0 0.0 3560 4 vc/1 S 10:24 0:00 -zsh
francois 2860 0.0 0.9 3900 2484 pts/1 S 13:43 0:00 /bin/zsh
francois 2996 0.0 0.8 3692 2212 pts/2 S 14:01 0:00 /bin/zsh
root 3469 0.0 0.8 3612 2084 pts/1 S 15:25 0:00 zsh
francois 3487 0.0 1.0 3976 2580 pts/1 S 15:25 0:00 zsh
root 4527 0.0 0.9 3768 2308 pts/2 S 19:49 0:00 zsh
francois 4607 0.2 0.8 3728 2268 pts/2 R 20:13 0:00 zsh
francois 4632 0.0 0.2 1904 760 pts/2 R 20:14 0:00 grep zsh
</code>
</hidden>

<hidden Que signifie le caractère > ou < (redirection) ? Quelle utilité ? >
Ce sont les opérateurs permettant de gérer les flux de données. La redirection '>' permet de stocker la sortie d'un programme dans un fichier. Cela crée le fichier s'il n'existait pas, et efface son contenu s'il existe (il faut donc faire attention !) :
<code>
$ cat fichier1 > fichier_sauvegarde
</code>
Si l'on veut rajouter des données au fichier, on utilisera la double redirection '>>' :
<code>
$ cat ajout >> fichier_sauvegarde
<code>
La redirection '<' joue le même rôle. Au lieu de taper au clavier le contenu du fichier, vous pouvez utiliser cette redirection et ainsi le fichier va se substituer a l'entrée standard (saisie clavier) :
<code>
$ cat < nom_du_fichier
$ cat < fichier1 > fichier_sauvegarde
</code>
Vous remarquerez que la dernière commande a le même effet que la première.
</hidden>

<hidden Que signifie le caractère | (pipe) ? Quelle utilité ? >
Le caractère '|' permet de lier des commandes entre elles. La sortie standard d'une commande devient l'entrée standard de la commande suivante :
<code>
$ cat fichier | grep YES
</code>
La commande cat envoie le contenu du fichier vers la commande grep qui va le lire. Bien entendu, si vous utilisez une commande qui ne lit pas de données sur l'entrée standard, cela n'aura aucun resultat :
<code>
$ cat fichier | ls
</code>
La commande cat envoie bien le contenu vers la commande ls, laquelle ne lit pas sur son entrée standard. Par conséquent, le pipe entre les deux commandes ne sert absolument à rien ;) 
Il est tout à fait possible d'enchaîner un très grand nombre de pipes (la limite dépend des shells).
<code>
nyal $ cat fichier | grep YES | sed 's/YES/NO/'
</code>
</hidden>

<hidden Que signifie le sticky bit ?>
Voici la signification du sticky bit :
  * sur un fichier : un programme executable sera maintenu en zone de swap après la fin de son exécution, ce qui accélerera les chargements ultérieurs
  * sur un répertoire : un fichier du répertoire ne peut être supprimé que par son propriétaire

Permettre à n'importe quel utilisateur de créer et modifier ses fichiers dans un répertoire, c'est mettre les droits rw (et x pour l'exploration) pour tous les utilisateurs (propriétaire, groupe et autres). Le stickybit sert juste à éviter qu'un utilisateur ne détruise les fichiers des autres. On le fixe de la manière suivante :
  * Pour le mettre
<code>
$ chmod a+t objet
</code>
  * Pour l'enlever
<code>
$ chmod a-t objet
</code>
C'est aussi le 1 de la première position lorsque l'on utiliser un masque à quatre chiffres avec la notation octale de chmod
</hidden>

<hidden Comment filtrer la sortie standard et/ou la sortie d'erreurs ?>
A l'aide des commandes grep et cut, on va extraire l'occurrence "/home/francois" du fichier /etc/passwd :
<code>
$ cat /etc/passwd | grep francois
francois:x:502:502::/home/francois:/bin/zsh
</code>
La commande grep permet de ne conserver que la ligne contenant "francois" de la sortie standard de cat.
<code>
$ cat /etc/passwd | grep francois | cut -f6 -d:
/home/francois
</code>
La commande cut permet de couper certains mots d'une ligne. L'option -f6 indique que l'on veut garder la 6ème chaîne de caractères, délimitée par le signe ':' (option - d).
</hidden>

<hidden Comment effacer des fichiers selon leur date ?>
La commande find permet de faire le plus rapidement possible ce genre de traitement. Pour afficher les fichiers vieux de plus de 24 heures :
<code>
$ find . -ctime +1
</code>
Pour les effacer :
<code>
$ find . -ctime +1 -exec rm -f  \{\} \;
<code>
L'option -i de la commande rm est utilisé pour demander une confirmation pour chaque fichier à effacer.
</hidden>

<hidden Que signifie le caractère ET commercial ? A quoi sert-il ? >
Ce caractère signifie que la commande sera exécutée en tâche de fond. Ainsi vous aurez toujours accès au shell pour exécuter d'autres commandes sur le terminal :
<code>
$ xmms &
$
</code>
</hidden>

<hidden Comment passer un processus en background si on a oublié le ET commercial ?>
Quand on lance une application depuis le terminal (genre xpdf, emacs, etc....) , on veut souvent reprendre la main sur ce meme terminal, non ?  Mais on a oublié le & magique ! C'est terrible, il va falloir tout refermer pour tout réouvrir ! Eh bien non : imaginons le cas :
<code>
$ xpdf toto.pdf
</code> 
Si on veut reprendre la main sans avoir a fermer, on revient sur le terminal, puis un petit Ctrl-Z histoire de geler le processus : là, on reprend la main. Et tout de suite derriere, on fait :
<code>
$ bg
</code>
</hidden>

<hidden Comment dialoguer avec un serveur ftp ?>
Il existe de nombreux programmes ftp en mode console. Voici un exemple pour exécuter des commandes ftp automatiquement :
<code>
$ lftp -c "open nom_de_domaine ; user login password ; mput src destination ; ls"
</code>
ou :
<code>
$ ncftp -u login -p passwd host << EOF
get fichier
ls
EOF
</code>
Ces méthodes sont utilisées dans les scripts shell (par cron notamment).
</hidden>

<hidden Démarrer un programme non-graphique en arrière plan et le rappeller à la volée ? >
La commande screen permet de lancer des processus non graphiques, qui seront rattachés au processus init. Ainsi, vous pourrez enlever votre programme de votre console et le rappellez quand vous le désirez. Pour cela, commençons par créer un screen :
<code>
screen -dmS nom_du_screen  'commande_a_lancer' 
</code>
Vous entrez directement dans votre screen en lancant la commande. Pour détacher le screen de votre terminal:
<code>
CTRL+A CTRL+D 
</code>
Pour attacher le screen à votre terminal :
<code>
$ screen -x nom_du_screen
</code>
Vous pouvez ainsi lancer un bash détachable de votre terminal et récupérable n'importe quand et n'importe où. Très pratique pour ne pas avoir beaucoup de fenêtres d'ouverts ou quand on se connecte à distance à une machine de différent poste. Les raccourcis claviers sont modifiables dans un fichier de configuration ''/etc/screenrc''.
</hidden>

<hidden Comment récupérer les 10 derniers caractères d'une chaine ? >
<code>
$ toto="bonjour le monde" 
$ echo ${toto:$((${#toto}-10))} 
r le monde 
</code>
  * extrait la sous chaine de ''$var'' à partir caractère n° x jusqu'à la fin:
<code>
${var:x} 
</code>
  * permet de faire des calculs:
<code>
$((...))
</code>
</hidden>

<hidden Comment faire une boucle sur une indice ? >
ou l'équivalent C++ à 
<code>
 for (int i=4; i<=8; i++) { ... }
</code>
<code>
for i in `seq 4 8`; do
   # commande
done 
</code>
Attention, car si vous voulez générer de grosses listes avec cette méthode, ça consomme de la mémoire (toutes les valeurs sont calculées et conservées).
</hidden>

<hidden Quelle est la différence entre nohup et le ET commercial  ? >
Lorsqu'on lance une commande avec le caractère ET commercial à la fin, la commande est lancée en tache de fond mais reste rattachée à votre terminal. Vous pouvez continuez à travailler sur le terminal mais si vous le quittez, la tache de fond est détruite (rapport père/fils). Si vous lancez une commande avec nohup en préfixe (exemple : nohup ma_tache.sh), alors votre tache est détachée de son père et rattaché à l'init si vous quittez votre terminal...
</hidden>===== Utilisation courante ======

<hidden Comment lire un pdf ? >
Les pdf peuvent être lus par différents programmes :
  * [[http://www.adobe.com/support/downloads/product.jsp?product=10&platform=unix|Acrobat Reader pour Linux]] (proche de la version windows)
  * gpdf (intégré à Gnome)
  * [[http://www.foolabs.com/xpdf/download.html|xpdf]]
  * [[http://www.gnu.org/software/gv/|gv]]
</hidden>

<hidden Comment lire les fichiers .bin et .cue ? >
Pour lire les fichiers .bin (fichier image des CD), il faut les convertir en fichier .iso. S'ils ne sont pas présents sur votre système, vous devez télécharger les programmes suivants :
  * [[http://he.fi/bchunk/|bchunk]]
  * [[http://users.eastlink.ca/~doiron/bin2iso/|bin2iso]]

Exemple d'utilisation :
<code>
$ bchunk file.bin file.cue new_file
$ mount -o loop new_file.iso /mnt/cdrom
</code>
Notez que des programmes graphiques comme [[http://www.k3b.org/|K3B]] (équivalent d'applications comme Nero sous Windows) gèrent ces formats de fichiers et permettent donc de graver très facilement.
</hidden>

<hidden Comment lire un fichier ps (postscript) ? >
Le langage postscript est un standard pour l'impression. Un fichier postscript peut être lu par le programme gs. Sinon, il peut être converti en un autre format (pdf, par exemple, via le programme ps2pdf).
</hidden>

<hidden Comment connaitre qui utilise un fichier/répertoire? >
Il vous suffit de lancer la commande 
<code>
$ fuser -c mon_fichier
</code>
Vous obtiendrez la liste des processus utilisant votre fichier. Vous pouvez aussi bien mettre un répertoire qu'un filesystem, vu que tout est fichier sous Unix.
</hidden>

<hidden Comment lire mes documents Microsoft Office ? >
La suite Open Office ([[http://www.openoffice.org/|OpenOffice.org]]) permet de lire et d'éditer des fichiers Microsoft Office (.doc, .ppt, ...).
En mode console, vous pouvez utiliser [[http://www.winfield.demon.nl/index.html|antiword]] notamment.
Si Open Office est la plus aboutie des suites bureautiques, il en existe aussi d'autres dont [[http://www.koffice.org/|KofficeØØ, du projet kde, et Star Office, de Sun, qui fait partie du Java Desktop Environnement.
</hidden>

<hidden Comment faire des screenshots (impressions d'écran) ? >
A l'aide d'applications GUI (Graphical User Interface) telles que :
  * Ksnapshot, du projet KDE
  * [[http://www.gimp.org/|The Gimp]]
En mode console ([[http://www.imagemagick.org/script/index.php|import]]) :
<code>
$ import screenshot1.png
</code>
</hidden>

<hidden Comment utiliser les archives gz ? > 
Les archives .gz peuvent être manipulées par la commande gzip. Compresser un fichier :
<code>
$ gzip test.txt
</code>
Décompresser un fichier :
<code>
$ gzip -d test.txt.gz
</code>
ou
<code>
$ gunzip test.txt.gz
</code>
</hidden>

<hidden Comment utiliser les archives bz2 ? >
Les archives bz2 se manipulent comme les archives gz. Compresser un fichier :
<code>
$ bzip2 test.txt
</code>
Décompresser un fichier :
<code>
$ bzip2 -d test.txt.bz2
</code>
ou
<code>
$ bunzip2 test.txt.bz2
</code>
Si vous souhaitez une meilleur compression, les archives bz2 sont conseillées.
</hidden>

<hidden Comment écrire/lire sur une disquette sans les mtools ? >
Si votre disquette est vierge, il faut d'abord la formater. Il est conseillé de choisir le système de fichier vfat pour que la disquette (1,44MB) soit utilisable sous windows (mais vous pouvez très bien formater en ext2 par exemple) :
<code>
$ mkfs.vfat /dev/fd0H1440
</code>
Ensuite, montez la disquette :
<code>
$ mount -t vfat /dev/fd0H1440 /mnt/floppy
</code>
Vous pouvez éditer, copier, effacer des fichiers avec les commandes Linux standard (cp, rm, ...).
N'oubliez pas de démonter la disquette avant de la retirer :
<code>
$ umount /mnt/floppy
</code>
</hidden>

<hidden Comment lire le contenu d'un CD de données ? >
Exécutez la commande :
<code>
$ mount -t iso9660 /dev/cdrom /mnt/cdrom
</code>
Si le lien /dev/cdrom n'existe pas, vous pouvez le créer en le faisant pointer vers votre lecteur de CD :
<code>
$ ln -s /dev/hdb /mnt/cdrom
</code>
Pour éjecter le CD, exécutez :
<code>
$ umount /dev/cdrom && eject
</code>
</hidden>

<hidden Comment monter ma clé USB ? >
Les périphériques USB sont émulés sur les périphériques SCSI, cela signifie que le device /dev/sda peut être soit un périphérique USB soit un SCSI.  Si vous ne possédez pas de périphérique SCSI, il y a de fortes chances que votre clé usb sera le device /dev/sda. Donc pour le monter, vérifier que vous avez bien les modules suivants dans votre noyau :
  * USB Mass Storage support
  * SCSI device support
  * SCSI disk support

Créez le répertoire de montage
<code>
$ mkdir -p /mnt/usb
</code>
puis faites le montage :
<code>
$ mount -t vfat /dev/sda1 /mnt/usb
</code>
Pour démonter la clef, c'est comme un filesystem normal.
<code>
$ umount /mnt/usb
</code>
</hidden>

<hidden Comment connaître le type MIME d'un fichier ? >
Avec la commande suivante : "file -i monfichier" qui retourne le type MIME du fichier par l'analyse des premiers octets du fichier. Le fichier ''/usr/share/magic.mime'' liste les types reconnus par votre système.
</hidden>

<hidden Comment installer le plugin Macromedia Flash sous Mozilla / Firefox ? >
Pour toute information sur l'installation de plug-ins pour les navigateurs de la famille Mozilla, rendez-vous ici : http://plugindoc.mozdev.org/linux.html. L'installation de Flash est très simple : après avoir téléchargé l'[[http://www.macromedia.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash&P2_Platform=Linux&P3_Browser_Version=Netscape4|archive .tar.gz]], décompressez-la et copier les fichiers suivants :
  * ''libflashplayer.so'' à copier dans le répertoire plugins, c'est-à-dire pour Firefox sur une Debian : ''/usr/lib/mozilla-firefox/plugins/''
  * ''flashplayer.xpt'' à copier dans le répertoire components, c'est-à-dire pour Firefox sur une Debian : ''/usr/lib/mozilla-firefox/components/''

Redémarrer le navigateur pour que le plug-in soit chargé.
</hidden>

<hidden Comment exécuter des applets java sous Mozilla / Firefox ? >
Il faut pour cela installer l'environnement Java sur votre machine : téléchargez la JRE sur le site de Sun qui est un fichier binaire et exécutez-le. Ceci fait, il faut créer un lien symbolique vers le fichier libjavaplugin_oji.so (composant de la JRE) dans le répertoire "plugins" de Mozilla/Firefox.
<code>
$ ln -s /usr/lib/j2re1.5-sun/plugin/i386/ns7/libjavaplugin_oji.so /usr/lib/mozilla-firefox/plugins/
</code>
Redémarrer le navigateur pour prendre en compte le nouveau plugin installé.
</hidden>


==== Manipuler des fichiers sous Unix/Linux ? ====

<hidden Comment afficher le contenu d'un fichier (cat) ? >
La commande cat permet d'afficher sur la sortie standard l'entier contenu d'un fichier. En voici les options :
  * v (Verbose) permet de convertir les caractères spéciaux des fichiers binaires en caractères affichables  
  * n (Number) numérote les lignes
  * b (number nonBlank) numérote que les lignes non vides
  * E (show Ends) affiche le symbôle $ (dollard) à la fin de chaque ligne
  * s (Squeeze blank) n'affiche au plus un ligne vide
  * T (show Tab) affiche les caractères tabulations comme ^I
  * A (show All) équivalent à -vET
  * e équivalent à -vE
  * t équivalent à -vT.

Exemple : 
<code>
$ cat lettre.tex
</code>

L'exemple précédent affiche à l'écran le contenu du fichier lettre.tex. Si le fichier avait été binaire, l'affichage des caractères spéciaux aurait provoqué un grave disfonctionnement du terminal d'affichage.

<code>
$ cat -v /bin/ls
</code>

L'ajout de l'option v permet de transformer les caractères de contrôle en caractères affichables à l'écran. Ceci est très utile pour rechercher des chaînes de caractères à l'intérieur d'un programme. A l'origine, cat permet de concaténer des fichiers et d'en renvoyer le résultat sur la sortie standard. Exemple : 
<code>
$ cat lettre.txt rapport.txt conclusion.txt
</code>
L'exemple précédent affiche à l'écran le contenu des fichiers ''lettre.txt'', ''rapport.txt'' et ''conclusion.txt''. Au lieu d'afficher sur la sortie standard le résultat de cette concaténation, on peut la rediriger vers un fichier. Syntaxe : ''cat fichier_1 fichier_2 fichier_3 > fichier_4''. Exemple : 
<code>
$ cat lettre.txt rapport.txt conclusion.txt > publication.txt
</code>
Ainsi le fichier ''publication.txt'' aura pour contenu la concaténation des fichiers ''lettre.txt'', ''rapport.txt'' et ''conclusion.txt''.
</hidden>

<hidden Comment afficher en inverse un fichier (tac) ? >
La commande ''tac'' est homologue à cat mais affiche le contenu d'un fichier en partant de la dernière ligne vers la première.
</hidden>

<hidden Comment afficher l'entête d'un fichier (head) ? >
La commande head permet de n'afficher que les permières lignes d'un fichier (10 par défaut). En voici les options :
  * cN affiche les N premiers octets
  * nN affiche les N premières lignes
  * q n'affiche pas le nom du fichier
  * v affiche le nom du fichier avant d'en afficher l'entête.

Exemples : 
<code>
$ head lettre.tex
</code>
Dans cet exemple, il s'affiche les 10 premières lignes du fichier lettre.tex, si ce dernier en contient moins de 10, il sera affiché dans sa totalité. 
<code>
$ head -n5 lettre.tex
</code>
Affichage des 5 premières lignes.  
<code>
$ head -vc20 lettre.tex
</code>
Affichage des 20 permiers caractères après le nom du fichier.
</hidden>

<hidden Comment afficher la fin d'un fichier (tail) ? >
La commande tail permet de n'afficher que les dernières lignes d'un fichier (10 par défaut). Elle est homologue à head et possède les mêmes attributs. Exemple : 
<code>
$ tail lettre.tex
</code>
Dans cet exemple, il s'affiche les 10 dernières lignes du fichier lettre.tex, si ce dernier en contient moins de 10, il sera affiché dans sa totalité.
<code>
$ tail -n5 lettre.tex
</code>
Affichage des 5 dernières lignes.
<code>
tail -vc20 lettre.tex
</code>
Affichage des 20 derniers caractères après le nom du fichier.
</hidden>

<hidden Comment afficher écran par écran un fichier (more et less) ? >
Les commandes more et less permettent d'afficher page par page des fichiers volumineux sur la sortie stantard. Pour passer à la page suivante : les touches fléchées. Pour effectuer un défilement vertical : touche ENTREE. Pour quitter : touche q.
</hidden>

<hidden Comment numéroter des lignes d'un fichier (nl) ? >
La commande nl permet l'affichage du contenu d'un fichier et en numérote les lignes. En voici les options :
  * bt numérote les lignes non-vides (par défaut)
  * ba numérote toutes les lignes
  * bpXXX numérote seulement les lignes qui contiennent la chaîne de caractères XXX
  * sX supprime le décalage du à la numérotation et utilise le séparateur X
  * s'XXX' supprime le décalage du à la numérotation et utilise la chaîne 'XXX'

Exemple : 
<code>
$ nl lettre.tex
</code>
Affiche le contenu du fichier lettre.tex en insérant le numéro de chaque ligne en début de ligne avec un espace comme séparateur entre le numéro et le premier caractère de chaque ligne. Ne numérote que les lignes non vides. Les lignes vides sont affichées.
<code>
$ nl -ba lettre.tex
</code>
Numérote et affiche toutes les lignes du fichier.  Synonyme de ''cat -n lettre.tex''. 
</hidden>

<hidden Comment afficher sans doublon les lignes d'un fichier (uniq) ? >
La commande uniq permet d'afficher le contenu d'un fichier ligne par ligne en ométant les doublons. En voici les options : 
  * u affichage sans doublon (par défaut) 
  * d affichage des doublons
  * c comptage des doublons

Exemple : 
<code>
$ uniq lettre.tex
</code>
Affiche le contenu du fichier lettre.tex sur la sortie standard en ométant les duplications de lignes lorsqu'elles sont contigues.
</hidden>

<hidden Comment afficher trié les lignes d'un fichier (sort) ? >
La commande sort permet de trier les lignes d'un fichier. En voici les options : 
  * b ignore les espaces en début de ligne
  * d ordre alphabétique (A-Z, a-z, 0-9, espace) (par défaut)
  * f ignore la casse
  * n ordre numérique
  * r inverse l'odre de tri.

Exemple : 
<code>
$ sort -bdf essai.txt
</code>
Cet exemple permet de trier les lignes du fichier essai.txt dans l'ordre alphabétique (d) sans tenir compte des espaces de début de ligne (b) et sans différencier majuscules et minuscules (f).
</hidden>

<hidden Comment afficher l'intersection de deux fichiers (uniq/comm) ? >
La commande uniq permet d'afficher le contenu d'un fichier (trié) ligne par ligne en ométant les doublons. En voici les options : 
  * u affichage sans doublon (par défaut) 
  * d affichage des doublons
  * c comptage des doublons

La commande comm affiche les lignes communes, et les lignes uniques des deux fichiers en entrée. Les deux fichiers doivent être triés.

Exemple : 
<code>
$ sort fichier1 fichier2 | uniq -d</code>
$ comm -12 fichier1 fichier2
Affiche l'intersection des deux fichiers.

$ sort fichier1 fichier2 | uniq -u</code>
$ comm -23 fichier1 fichier2
Affiche les lignes présentent dans fichier1 mais absentes de fichier2
</hidden>

<hidden Comment découper un ficher (split) ? >
La commande split permet de découper un fichier en plusieurs plus petits. Ses options sont :
  * b n (Bytes) découpage par blocs de n octets
ou
  * l n (Lignes) découpage par blocs de n lignes

Exemple : 
<code>
$ split -b 135000 vacances.mpeg
<code>
Ici on découpe le fichier vacances.mpeg qui est une vidéo volumineuse en fichiers de 1.35 Mo afin de la sauvegarder sur disquettes (de capacité maximum de 1.44 Mo).

Par défaut, les fichiers issus de la découpe auront un nom ayant pour préfixe x et pour suffixe une suite de lettre du type aa, ab,ac... créés dans l'ordre lexicographique naturel (descendant de 'a' vers 'z').  Pour changer le préfixe, il suffit de le spécifier en fin de commande. Exemple : 
<code>
$ wc -l 100 /var/log/httpd/access.log access.log.
</code>
Ici on découpe le fichier de log du serveur HTTP en plus petits fichiers de 100 lignes chacun. Dont le nom sera du type'' access.log.aaa'', ''access.log.aab'', etc.\\

Note : pour découper des fichiers texte brut, faire la découpe en nombre de lignes. Tandis que pour découper les fichiers binaires, utiliser la découpe en nombre d'octets.\\

Etude d'un cas d'école : on dispose du fichier cours_de_c.pdf qu'on souhaite sauvegarder sur disquette. Or la commande ls (voir Système de fichiers sous Unix > Lister les fichiers) nous apprend qu'il fait 5.7 Mo, ce qui est trop grand pour le copier directement sur disquette.  On va dont le compresser avec l'utilitaire gzip (voir Compression > Le compresseur gzip) afin d'en réduire la taille. Le fichier résultant cours_de_c.pdf.gz fait tout de même 2.8 Mo, ce qui reste encore trop.  On va donc utiliser notre recours ultime : le saucissonage de notre fichier en plusieurs plus petits de taille 1.3 Mo pour être sûr qu'ils rentreront dans les disquettes dont on dispose. Commande : 
<code>
$ split -b 130000 cours_de_c.pdf.gz cours_de_c.pdf.gz.
</code>
Ce qui nous crée les fichiers suivants :
  * ''cours_de_c.pdf.gz.aa'' (1.3 Mo)
  * ''cours_de_c.pdf.gz.ab'' (1.3 Mo)
  * ''cours_de_c.pdf.gz.ac'' (200 Ko)
que l'on va copier chacun dans une disquette. Pour retrouver le fichier de départ, on concatène et on décompresse. Commandes :
<code> 
$ cat cours_de_c.pdf.gz.* > cours_de_c.pdf.gz
$ gunzip cours_de_c.pdf.gz
$ acroread cours_de_c.pdf
</code>
</hidden>

<hidden Comment afficher les différences entre plusieurs fichiers (diff) ? >
La commande diff permet de comparer le contenu de deux fichiers pour en conaître les différences. Ceci est très pratique pour savoir si deux fichiers ont le même contenu. En voici quelques options : 
  * b ignore les différences du à des espaces blancs
  * B ignore les différences du à des lignes blanches
  * i ignore les différences minuscules/MAJUSCULES
  * q indiquer seulement si les fichiers sont différents et ne pas afficher les différences elles-mêmes
  * s indiquer lorsque deux fichiers sont identiques
  * r comparaison récursive des fichiers d'un répertoire, sous répertoires...

Exemple : 
<code>
$ diff .signature .signature.old
3a4
> .signature.old
</code>
Ici on peut voir qu'il y a une différence entre les ligne 3 et 4 dans le fichier .signature.old où i ly a une ligne insérée. S'ils avaient été égaux, diff n'aurait rien affiché. \\
Exemple:
<code>
$ diff -q .signature .signature.old
Files .signature and .signature.old differ
</code>
Exemple : 
<code>
$ diff -q .signature .signature
Files .signature and .signature are identical
</code>
</hidden>

<hidden Comment obtenir des statistiques sur un fichier (wc) ? >
La commande wc permet de compter le nombre de caractères, de mots et de lignes d'un fichier. Ses options sont :
  * l (Lignes) compte le nombre de lignes
  * w (Words) compte le nombre de mots
  * c (Chars) compte le nombre de caractères
  * L (Length max ligne) affiche la longueur de la ligne la plus longue

Exemple : 
<code>
$ wc mail.txt
</code>
Sans options, wc renvoie atomatiquement le nombre de de lignes (l), de mots (w) et de caractères (c).\\

Exemple : 
<code>
$ wc -lL mail.txt
</code>
Renvoie le nombre de lignes (l) et la taille maximale d'une ligne (L). \\

Exemple :
<code>
$ wc mail.txt
12     108     671   mail.txt
</code>
Dans l'exemple précédent, le fichier mail.txt comporte 12 lignes, 108 mots et 671 caractères.
</hidden>

<hidden Comment obtenir le type d'un fichier (file) ? >
La commande file permet de connaître le type d'un fichier. Cette commande retourne le type d'un fichier passé en paramètre. Pour opérer, elle fait appel à un fichier qui contient les signatures binaires d'un grand nombre de fichier. Elle est par exemple capable de fournir les caractéristiques du système qui a compilé un fichier exécutable parmis plusieurs centaines. Exemple :
<code> 
$ file ../*
../DATA:       directory
../cv.doc:     Microsoft Word document
../tp6.c:      program text C++
../mail.txt:   international ascii text
</code>
Dans l'exemple précédent, on souhaite connaître le type de tous les fichiers du répertoire parent. La précision de la commande dépend du fichier magic qu'elle appelle.
</hidden>

<hidden Comment créer de fichier (touch) ? >
La commande touch permet de créer un nouveau fichier vide. Syntaxe : 
<code>
$ touch fichier
</code>
Appliquée à un fichier déjà existant, elle modifie son heure de dernier accès et met cette dernière à l'heure courante par défaut.
</hidden>


<hidden Comment trouver un fichier ? >
Il existe plusieurs façons de procéder pour trouver un fichier sous Linux. La méthode la plus utilisée est la commande locate :
<code>
$ locate nom_du_fichier 
</code>

Cette commande affichera toutes les occurrences trouvées. Que ce soit une partie du nom d'un répertoire ou d'un fichier. Il se peut donc qu'il y ait beaucoup d'occurrences !\\

NB : Pour que la commande locate fonctionne, il faut préalablement créer sa base de données utile. Il faut pour cela éxecuter la commande updatedb en tant que root. Cette commande permet également de mettre à jour la base de données (sinon les modifications du système de fichier ne seront pas prises en compte) : il est donc judicieux de l'exécuter régulièrement (via un cron), par exemple.\\

Une autre méthode est d'utiliser la commande find :
<code>
$ find / -name "fichier.txt"
</code>
Cette commande affichera tous les fichiers se nommant fichier.txt à partir du répertoire racine. Il est possible d'utiliser les expressions régulières :
<code>
$ find / -name "toto*"
</code>
Le résultat sera tous les fichiers et répertoires commençant par toto, suivi de n'importe quelle occurrence. Pour éviter d'avoir les "permission denied" sur des répertoires :
<code>
$ find / -type f -name "le_fichier_a_chercher" 2>/dev/null 
</code>
find est très puissant, et permet aussi d'employer les expressions régulières, comme le montre l'exemple suivant qui permet de trouver tous les fichiers contenant une chaine ou une regexp dans une arborescence :
<code>
$ find <repertoire_depart> -type f -exec grep -H "<chaine_ou_regexp>" {} ;
</code>
Lorsqu'il s'agit de gros volumes de fichiers :
<code>
$ find <repertoire_depart> -type f | xargs grep -H "<chaine_ou_regexp>"
</code>
Renommer tous les fichiers conenant chaine en chene :
<code>
$ for i in `ls *chaine*` ; do mv $i `echo $i | sed 's/chaine/chene'` ; done
</code>
En récursif sur une arborescence :
<code>
$ for i in `find . -type f -name "*chaine*" ; do mv $i `echo $i | sed 's/chaine/chene'` ;done
</code>
Il y a même moyen d'effectuer des opérations sur fichier en appelant des scripts externes; par exemple : changer toutes les option=true en option=false dans tous les fichiers *.conf en recursif en gardant une copie de sauvegarde :
<code>
$ find . -type f -name "*.conf" | xargs perl -pi.save -e 's/option\=true/option\=false/'
</code>
</hidden>


==== Multimedia ==== 

<hidden Comment lire mes divx ? >
Pour lire les divx, il vous faut un lecteur multimedia. Il en existe une multitude dont notamment :
  * [[http://www.mplayerhq.hu/design7/news.html|MPlayer]]
  * [[http://www.xine-project.org/home|Xine]]
  * [[http://www.videolan.org/|Videolan]]
Exemple d'utilisation:
<code>
$ mplayer test.avi
</code>
</hidden>

<hidden Comment lire mes dvd ? >
Il vous faut d'abord vous assurer que /dev/dvd pointe bien sur votre lecteur dvd (les lecteurs utilisent ce lien par défaut) :
<code>
$ ln -s /dev/hda /dev/dvd
</code>
Ensuite, installez un des lecteurs suivants :
  * [[http://www.dtek.chalmers.se/groups/dvd/|ogle]] (premier lecteur à supporter les menus)
  * [[http://projects.gnome.org/totem/|Totem]]
  * [[http://www.xine-project.org/home|Xine]]
  * [[http://www.videolan.org/|Videolan]]
  * [[http://www.mplayerhq.hu/design7/news.html|MPlayer]] (pas encore de support des menus)
Lire le titre 1 du dvd :
<code>
$ mplayer dvd://1
</code>
Lecture de la piste audio anglaise, avec sous-titres français, du chapitre 1 au 4 :
<code>
$ mplayer dvd://1 -alang eng -slang fr -chapter 1-4
</code>
Attention, vous aurez besoin de la librairie libdvdcss2 qui permet de décrypter le contenu des DVD, celle-ci n'étant pas toujours fournie de base avec toutes les distributions pour des raisons légales et de licence.

</hidden>

<hidden Comment lire le contenu d'un CD-Audio ? >
La plupart des distributions ont des programmes pour lire les fichiers audio ou CD audio, citons-en : [[http://www.xmms.org/|XMMS]] connu comme un équivalent de Winamp sous Windows. D'autres lecteurs multimédia le permettent également, comme Xine par exemple.
</hidden>
 

==== Linux et les autres systèmes ====

<hidden Comment lire une disquette dos ? Utilisation des mtools. >
If faut utiliser les [[http://www.gnu.org/software/mtools/intro.html|mtools]]. Les MTools sont un ensemble d'instructions qui permettent de travailler sous Unix avec des disquettes au format MS-DOS. Le système de fichier (FAT) d'étant pas codé de la même façon sous Dos et sous Unix, il est nécessaire de faire des convertions de format de données lorsqu'on souhaite transférer des fichiers du système Unix vers les compatibles IBM. \\

Ces commandes sont les homoloques de celles du Dos dont vous reconnaîtrez par ailleurs la syntaxe.
</hidden>

<hidden Comment faire tourner des jeux/applications windows ? (wine) >
Le programme Wine permet d'exécuter des applications Windows sous linux dans une certaine mesure. Soit il utilise les bibliothèques d'une installation Windows existante sur votre disque dur, soit il installe ses propres bibliothèques de compatibilité, qui transforment les appels de l'API Windows en équivalents sous l'environnement Unix X Window.\\

La compatibilité n'est pas parfaite et certaines applications ne tourneront pas ou bizarrement, mais les applications classiques de gestion/bureautique fonctionnent la plupart du temps. Vous pouvez donc surfer avec Internet Explorer sous linux si vous le désirez.
</hidden>

<hidden Peut on accéder à une partition Linux depuis Windows ? >
Oui ! Grâce à [[http://www.chrysocome.net/explore2fs|explore2fs]].
</hidden>

<hidden Comment lire/écrire sur une partition windows ? >
Il existe deux systèmes de fichiers (les plus utilisés) sous windows : FAT et ntfs. Le FAT ne pose aucun problème de lecture ou d'écriture sous linux. Il suffit d'exécuter la commande suivante en root :
<code>
$ mount -o umask=020 -t vfat /dev/partition_windows /mnt/rep
</code>
Les utilisateurs peuvent ensuite manipuler les données windows a l'aide des commandes standard UNIX (ls, cd, cp, rm, etc). Par contre, le système de fichier ntfs pose un problème d'écriture. Il est aujourd'hui encore très incertain d'écrire des données sur une partition ntfs. Accéder a une partition ntfs (commande en root) :
<code>
$ nyal # mount -o umask=020 -t ntfs /dev/partition_windows /mnt/rep
</code>
NB : Il se peut que la commande ne fonctionne pas. Cela peut provenir du fait que votre kernel ne possède pas les bonnes fonctionnalités (gestion vfat, ntfs). 
</hidden>


===== Administration =====

<hidden Comment régler l'heure ? >
Pour régler l'heure, vous pouvez utiliser la commande date (date [MMDDhhmm[[CC]YY][.ss]]) :
  * MM : mois
  * DD : jour du mois
  * hh : heures (24h)
  * mm : minutes
  * CC : siècle (19 pour 1994 par exemple)
  * YY : année sur 2 chiffres

Exemple pour régler l'heure au 11 juin 2004 à 22h46 :
<code>
$ date 061122462004
</code>
</hidden>


<hidden Qu'est-ce que le chroot et à quoi ça sert ? >
Le "chroot" est un mécanisme qui permet de changer virtuellement le répertoire racine ("/", ou "root") d'un répertoire donné. Ce mécanisme est notamment utilisé pour sécuriser le système : si un pirate parvient à pénétrer dans un répertoire "chrooté" (''/var/www/'', par exemple), il n'aura pas pour autant accès au "vrai" système de fichiers.
Il est également utilisé pour l'installation de méta-distributions telles que [[http://www.fr.linuxfromscratch.org/|Linux From Scratch]] ou [[http://www.gentoo.org/|gentoo]].
</hidden>

<hidden Comment (dés)activer ctrl+alt+del ? >
Pour désactiver ctrl+alt+del, il vous faut mettre en commentaire (en insérant le caractère # devant), ou effacer la ligne suivante dans le fichier /etc/inittab (cette ligne peut différer sur votre système) :
<code>
ca::ctrlaltdel:/sbin/shutdown -t5 -rf now
</code>
Il est possible de spécifier une autre tâche, comme effacer un répertoire ou autre chose. Mais cela n'est pas spécialement fait pour cela.
</hidden>

<hidden Connaître l'espace disque sur les différentes partitions ? >
Vous pouvez pour cela utiliser df (disk free), exemple :
<code>
$ df -h
SysFichier Tail. Util.Disp. Uti% Monté sur
/dev/hda5 4,3G 3,2G 865M 79% /
/dev/hda7 2,7G 2,1G 634M 77% /home
</code>
</hidden>

<hidden Comment connaître l'état de la batterie (pour pc portable) ? >
En utilisant la commande apm, exemple :
<code>
$ apm
AC on-line, battery status critical: 100%
</code>
</hidden>

<hidden Comment lancer des commandes root en étant loggé en tant qu'utilisateur normal ? >
Il existe plusieurs méthodes (bit SUID notamment), mais je n'évoquerai ici que la méthode sudo. Exécutez la commande visudo qui va en fait lancer votre éditeur favori pour modifier le fichier ''/etc/sudoers''. Vous pourrez alors rajouter la ligne :
<code>
nom_utilisateur ALL=(ALL) NOPASSWD:ALL
</code>
L'utilisateur spécifié peut maintenant exécuter des commandes réservées au root en tapant :
<code>
$ sudo commande
</code>
Le paramètre "NOPASSWD" indique à sudo qu'il ne doit demander le mot de passe de l'utilisateur avant de lancer la commande.
</hidden>

<hidden J'ai perdu mon password root. Comment le récupérer ? >
Il n'est pas possible de récupérer son password root. Mais vous pouvez changer ce password si vous avez accès physiquement à l'ordinateur. Vous devez d'abord trouver un moyen d'accéder à une console (utilisation d'une distribution live-CD comme la knoppix, boot sur un cd d'installation de linux, etc). Montez ensuite la partition racine de votre linux dans un répertoire :
<code>
$ mount -t ext2 /dev/hda1 /mnt
</code>
Exécutez les commandes :
<code>
$ cd /mnt
$ chroot /mnt 
</code>
Il ne vous reste plus qu'à changer le password :
<code>
$ password root
</code>
Maintenant, vous pouvez relancer linux et utiliser votre nouveau password pour le compte root.
</hidden>

<hidden Comment rajouter une partition pour un répertoire existant? >
Le problème est simple: pas de LVM et une distribution de plus en plus serrée, pas moyen de redimensionner les partitions donc on en crée une autre (sur un autre disque ou y'a de la place par exemple) et on y copie une grosse partition qui prend de la place comme ''/usr''. On démarre en mode single
<code>
$ init s
</code>
Création d'un système de fichiers sur la nouvelle partition + répertoire pour copier le contenu
<code>
$ mkfs.ext3 /dev/hdxx
 mkdir -p /mnt/new_usr
</code>
On monte la nouvelle partition et on copie les données sur la nouvelle partition
<code>
$ mount /dev/hdxx /mnt/new_usr
$ cp -arf /usr/* /mnt/new_usr/
<code>
Rajoute la bonne ligne au fichier ''fstab''
<code>
$ echo "/dev/hdxx /usr ext3 defaults 1 1" >> /etc/fstab
</code>
On supprime ce que l'on a copié: attention mieux vaut attendre d'avoir vérifié que ça marche avant de faire cette manip' délicate quque soit la partition
<code>
$ rm -rf /usr/* 
</code>
On démonte la partition que l'on a crée dans le seul but de copier /usr (ou notre répertoire on monte ce que l'on vient de copier et on supprime le répertoire /mnt crée pour l'occasion
<code>
$ umount /mnt/new_usr
$ mount /usr
$ rmdir /mnt/new_usr
<code>
on peut relancer le système, soit par un reboot, soit remettant le runlevel habituel
<code>
$ reboot ( ou init X )
<code>
</hidden>


==== Noyau ====

<hidden Quelle est la version de mon kernel ? >
Vous pouvez connaître la version de votre noyau grâce à la commande :
<code>
$ uname -r
</code>
</hidden>

<hidden Avoir des infos sur mon processeur (en + précis que arch ou uname) ? >
En lisant le contenu de cpuinfo :
</code>
$ cat /proc/cpuinfo
</code>
ou
<code>
$ dmesg | grep CPU
</code>
</hidden>

<hidden Comment avoir des infos sur son matériel ? >
Vous avez à votre disposition des commandes telles que ''lspci'' (ou, pour plus d'infos : ''lspci -v''), ou encore ''lsusb''.
</hidden>

<hidden Comment désactiver les messages du noyau lors d'un montage ? >
Il suffit de modifier les données dans ''/proc/sys/kernel/printk'' en remplaçant
<code>
7 4 1 7
</code>
par
<code>
4 4 1 7
</code>
</hidden>


==== Système ====

<hidden Comment éteindre/rebooter la machine ? >
En principe, seul l'administrateur a le droit d'éteindre ou de rebooter la machine.
Rebooter :
<code>
$ shutdown -r now
$ reboot
$ init 6
</code>
Eteindre :
<code>
$ shutdown -h now
$ halt
$ poweroff
$ init 0
</code>
</hidden>

<hidden Comment programmer l'exécution d'une tâche à intervalle régulier ? >
Le programme cron est conçu pour cela. Cron est un démon Unix. Chaque utilisateur dispose d'un fichier, dit cron table, qui contient les noms des programmes à lancer et leur fréquence d'exécution. Crontab est le programme qui sert d'interface au démon cron. Il peut-être appelé de quatre façons : 
  * crontab nom_de_fichier va définir nom_de_fichier comme cron table de l'utilisateur courant.
  * crontab -l va afficher le contenu de la cron table de l'utilisateur courant.
 * crontab -r va supprimer la cron table de l'utilisateur courant.
Enfin, crontab -e va lancer l'éditeur de texte par défaut pour modifier la cron table de l'utilisateur courant (équivalent de vi /etc/crontab, si vi est l'éditeur par défaut).\\

Exemple de cron table :
<code>
# chaque minute
* * * * * * /bin/checkmail
# chaque jour de la semaine à 8h30, sauf en juillet et en août
30 8 * 1,2,3,4,5,6,9,10,11,12 1-5 /bin/work
# chaque vendredi à 18h
0 18 * * 5 /bin/bye
# et tous les 14 jours à 8 heures (mais pas un jour de week end)
0 8 */14 * 1-5 /bin/boss
</code>
</hidden>

<hidden Pourquoi mon programme en cron ne fonctionne pas ? >
La principale source d'erreur est la ligne de commande
<code>
00 01 * * * touch aa
</code>
Le système ne sait pas ou se trouve touch ou aa ...
Mettez donc toujours les chemins entiers pour atteindre les fichiers/executables...etc
<code>
00 01 * * * /bin/touch /tmp/aa
</code>
</hidden>

<hidden Comment synchroniser l'horloge sur un référentiel atomique ? >
Grâce au programme ntpdate qui utilise le protocole NTP pour synchroniser l'horloge du PC sur un serveur de temps distant, en général lui-même synchronisé sur un serveur relié à une horloge de précision atomique. Une fois le programme installé, la commande est excessivement simple :
<code>
$ ntpdate serveur.de.temps
</code>
Exemple pour la Belgique :
<code>
ntpdate ntp.belnet.be
</code>
</hidden>

<hidden Comment arrêter un programme planté ? >
Si le programme n'est pas lancé en tâche de fond et que vous avez accès au terminal de lancement, tapez ctrl+c. Si cela ne fonctionne pas, vous pouvez essayer ctrl+z pour suspendre le programme et ainsi récupérer le shell. Vous pouvez aussi utiliser un autre terminal et exécuter la commande :
<code>
$ killall -9 nom_du_programme
</code>
Si la commande échoue :
<code>
$ kill -9 pid_du_programme
</code>
Pour identifier le pid du programme, lancez la commande ps :
<code>
$ ps -ax | grep nom_du_programme
</code>
Le pid du programme est le premier nombre. Sinon, vous pouvez faire :
<code>
$ kill -9 `ps -ax | grep nom_du_logiciel  | awk '{ print $1}'`
</code>
Sous l'environnement graphique X Window la même méthode marche toujours, mais est souvent plus difficile car le nombre de processus est important, et repérer le bon n'est pas toujours évident. Le plus simple est d'utiliser xkill qui est un kill en mode graphique : votre curseur se transforme en croix et il suffit alors de cliquer sur la fenêtre qui ne répond plus pour tuer aussitôt le processus planté.
</hidden>

<hidden Que sont les touches magiques ? A quoi servent-elles ? >
Ce sont des combinaisons de touches qui permettent de passer des ordres directement au noyau. Elles peuvent utiles en cas de plantage (écran noir, souris hs, clavier apparemment bloqué...), car elles peuvent vous éviter d'avoir recours au brutal reset. C'est en effet le noyau qui gère les entrées clavier, et qui transmet les codes correspondants aux différents périphériques. Certaines combinaisons lui sont réservées :
  * Alt + SysReq + R (Raw) : les codes "brutes" ds touches seront transmis (pas de translation).
  * Alt + SysReq + S (Sync) : vide les buffers (ou cache disque).
  * Alt + SysReq + U (Unmount) : démonte les partitions et les remonte en lecture seule.
  * Alt + SysReq + E (tErm) : envoie le signal SIGTERM aux applications pour un arrêt "propre".
  * Alt + SysReq + I (kIll) : envoie le signal SIGKILL aux applications pour un arrêt forcé.
  * Alt + SysReq + B (reBoot) : redémarre le système.
(la touche SysReq est aussi appelée PrintScr ou ImprEcran)

Ces touches ne fonctionneront que si le noyau lui-même n'est pas planté, bien entendu ; mais il faut que l'option correspondante (Kernel Hacking >> Magic SysRq keys) ait été sélectionnée lors de la compilation. Certaines distributions compilent ainsi leur noyau ; d'autres non. \\

Il existe une autre combinaison "magique" qui permet, s'il est planté, de "tuer" le serveur X et de revenir à la console : Ctrl+Alt+backspace.

</hidden>

<hidden Comment rajouter de la mémoire swap sans partition ? >
Il est parfois util d'ajouter 512Mo de swap pour quelques jours ou quelques heures pour des logiciels très lourds comme le rendering blender ou le montage video etc.... Exemple de méthode simple permettant la création d'un fichier swap de 512 Mo :
<code>
$ dd if=/dev/zero of=/file.swap bs=512M count=1 
$ sync 
$ mkswap -c /file.swap 
$ chmod -v 600 /file.swap 
$ swapon /file.swap 
<code>
Mettre hors service le fichier swap :
<code>
$ swapoff /file.swap 
</code>
Attention !  ne supprimer pas un fichier swap en service
</hidden>

<hidden Comment créer un fichier d'échange 'local' ? >
Si pour une raison ou une autre, vous ne voulez pas créer un fichier d'échange (swap) sous forme d'une partition, sachez qu'il est possible de créer une zone d'échange sous forme de fichier sur votre partition actuelle sans avoir à toucher aux partitions de votre disque dur.  Pour cela :
<code>
dd if=/dev/zero of=/my_swap bs=1024k count=128
</code>
Ici :
  * ''/dev/zero'' permet de créer un fichier "vide"
  * ''/my_swap'' représente le nom du fichier d'échange, vous pouvez bien sûr le nommez comme vous voulez et le placer où vous le désirez
  * ''bs=1024k'' représente la taille du fichier. Ici, un fichier de 128Mo est créé

Puis on créé le swap proprement dit :
<code>
$ mkswap /my_swap
</code>
Ici ''/my_swap'' est a remplacer par le nom que vous avez donné au fichier précédemment créé.  Enfin, on monte le fichier swap :
<code>
$ swapon -p2 /my_swap
</code>
Si l'on veut automatiser le montage du swap, il faut rajouter la ligne suivante dans le fichier ''/etc/fstab'' :
<code>
/my_swap	swap		swap	defaults,pri=2	0	0
</code>
</hidden>

<hidden Comment récupérer le superblock avec fdisk? > 
Perte du Super Block ! Pour certaines raisons, il arrive que le superblock d'un filesystem soit corrompu. Executez :
<code>
$ mkfs -n /dev/ma_partition
</code>
pour simuler un formattage de la partition. Mkfs va relancer son algorithme pour déterminer les backups du superblock! Vous aurez ainsi à l'écran les numéros des superbloks, qui vous a été donnés au moment du vrai formatage. Vous pouvez ainsi les noter et lancer un fsck en donnant un autre des superblocks pour réparer la partition
<code>
$ fsck -b mon_superblock_de_secours /dev/ma_partition
</code>
</hidden>

<hidden Comment vérifier physiquement mon disque? Des clusters défectueux ? >
Pour effectuer une vérification de vos clusters défectueux, il existe la commande : badblocks

# badblocks /dev/hdb1
Par défaut, seul un test de lecture non-destrutif est effectué. Pour effectuer un test d'écriture en mode destructif, utilisez l'option -w. Comme son nom l'indique, le mode destructif supprimera l'ensemble des données de la partition!!! Pour effectuer un test d'écriture en mode non-destructif, préférez l'option -n. Il existe aussi un protocle appellé S.M.A.R.T. implémenté sur les disques durs. Installez le package "smartmontools". Lancer la commande
<code>
$ smartctl -t long /dev/hdX
</code>
Pour voir ensuite le résultat, il faut patienter quelques minutes avant de demander d'afficher le rapport :
<code>
$ smartctl -l selftest /dev/hdX
</code>
Il y a aussi moyen de lancer un "scandisk" par la commande fsck /dev/hda1 par exemple. Le problème c'est que si votre partition est montée (ce qui est forcément le cas) la vérification risque d'entraîner de graves problèmes. L'astuce est donc d'effectuer ce test de disque juste avant de monter la partition, c'est-à-dire lors de la séquence d'initialisation du système. Pour forcer fsck à se lancer au prochain démarrage, il suffit de créer un fichier /forcefsck à la racine du système de fichiers, puis de rebooter. Linux va alors analyser toutes les partitions physiques de type linux déclarées dans le /etc/fstab et récupérer les erreurs qui peuvent l'être.
</hidden>

<hidden Comment vérifier la complexité des mots de passe ? >
Il vous suffit d'installer le logiciel john. Faites une copie du /etc/shadow dans le répertoire root et lancer john
<code>
$ cp /etc/shadow /root/
$ cd /root
john shadow
</code>
Vous pouvez arréter le traitement à tout moment via Ctrl+C et le reprendre par :
<code>
$ john -restore
</code>
Le traitement est assez long et prend du temps CPU.
</hidden>

<hidden Comment désactiver un compte utilisateur ? >
Pour désactiver un compte, il faut modifier deux paramêtres à l'utilisateur:
  * La date d'expiration du mot de passe.
  * Le nombre de jours entre la date d'expiration du mot de passe et la désactivation du compte. 
  * La commande usermod vous le permet :
<code>
$ usermod -e 2005-12-05 -f 3 mon_user
</code>
Si le paramêtre f est à 0, dès l'expiration du mot de passe, le compte est désactivé (par défault, il est à -1, pas de désactivation). Il est important de ne jamais supprimer un compte. L'utilisateur étant référencé pour les droits des fichiers par exemple, dans les groupes, etc.
</hidden>

<hidden Comment connaitre la charge machine? >
En utilisant la commande "w" qui permet de connaitre le nombre de clients connectés a la machine, ainsi que le load average, c'est a dire la charge de la machine. Quand le load average dépasse 3 c'est mauvais signe. Celui ci représente le nombre moyen de processus en file d'attente.
</hidden>


==== Le démarrage ====

<hidden Comment remettre l'amorcage de Windows? Supprimer lilo/grub? > 
Il existe plusieurs méthode suivant le cd de windows que vous avez. La version de windows que vous avez installez n'importe pas (vous pouvez fixer le mbr de windows 2000 avec un cd de win98). \\

Si vous possédez un CD de windows XP/2k
  * Booter sur le CD et choisissez la console de récupération
  * tapez : fixmbr\\

Si vous possédez un CD de windows 98 ou une disquette de démarrage dos
  * Booter sur le CD et démarrez en mode dos (avec ou sans prise en charge du cdrom, aucune différence) 
  *  tapez : fdisk /mbr
Ainsi, le MBR du disque est désormais restauré par celui de Windows.
</hidden>

<hidden Pourquoi les images du noyaux sont en double dont une suffixée par -smp ? >
L'installation de Linux détecte les cartes mères compatibles SMP (Symmetric MultiProcessing), c'est-à-dire offrant une architecture haute performances à multiples CPU. \\

En cas de carte mère SMP détectée, deux entrées sont créées dans grub.conf et lilo.conf. Elles renvoyent vers des images du noyau aux mêmes fonctionnalités mais celle suffixée par -smp (Grub) est adaptée aux spécificités SMP, celle suffixée par -up (Lilo) n'est pas spécifique à SMP.

</hidden>

<hidden Comment sauvegarder son mbr? >
Via ''dd'', vous pouvez sauvegarder votre mbr
<code>
$ dd if=/dev/hda of=/tmp/mon_mbr bs=512 count=1
</code>
Pour le restaurer... bah l'inverse
<code>
dd if=/tmp/mon_mbr of=/dev/hda bs=512 count=1
</code>
</hidden>


=== LILO ===

<hidden Comment faire en sorte que LILO lance par défaut Windows au lieu de Linux ? >
Il faut éditer le fichier ''/etc/lilo.conf'' et de remplacer la ligne default="linux" par default="windows". Ensuite dans une console il suffit de taper :
</code>
$ lilo
</code>
Puis de rebooter la machine.
</hidden>

<hidden Comment supprimer le chargeur d'amorçage ? >
Pour LILO, exécuter :
<code>
$ lilo -u
</code>
Indépendamment du chargeur d'amorçage, exécuter (sous dos) :
<code>
$ fdisk /mbr
</code>
</hidden>

<hidden Comment changer la résolution de Lilo? >
Dans la configuration lilo, si vous voulez changer la résolution de démarrage, mettez la valeur suivante dans l'option vga=xxx: 
  * 8 bits:
<code>
640x480	769
800x600	771
1024x768	773
1280x1024	775
</code>

  * 16 bits:
<code>
640x480	785
800x600	788
1024x768	791
1280x1024	764
</code>

  * 32 bits:
<code>
640x480	786
800x600	789
1024x768	789
1280x1024
</code>
</hidden>

<hidden Comment restaurer lilo avec l'installation de Windows? >
Prendre un cd live (Knoppix par exemple) et booter ton ordi dessus. Montes ta partition ''/'' de ton système (par exemple ''/dev/hdaX'') dans ''/mnt''.
<code>
$ mount /dev/hdaX /mnt
</code>
Change le répertoire de root
<code>
$ chroot /mnt
</code>
Mances lilo pour mettre à jour le MBR.
<code>
$ lilo
</code>
Puis sorw
<code>
$ exit
</code>
Démontage pour faire propre
<code>
$ cd / ; umount /mnt
</code>
Et reboot de l'ordinateur.
</hidden>


=== Grub ===

<hidden Comment faire en sorte que Grub lance par défaut Windows au lieu de Linux ? >
Dans le fichier ''/boot/grub/menu.lst'', faites les modifications suivantes :\\
Le bloc servant à démarrer Windows
<code>
title      Microsoft Windows XP Professionnel
root      (hd0,0)
savedefault
makeactive
chainloader   +1
</code>
Il suffit en effet de mettre ce bloc en tête des autres blocs. Vous obtenez :
<code>
title      Microsoft Windows XP Professionnel
root      (hd0,0)
savedefault
makeactive
chainloader   +1

title      Debian GNU/Linux, kernel 2.4.27-2-386
root      (hd0,3)
kernel      /boot/vmlinuz-2.4.27-2-386 root=/dev/hdb4 ro
initrd      /boot/initrd.img-2.4.27-2-386
savedefault
boot

title      Debian GNU/Linux, kernel 2.4.27-2-386 (recovery mode)
root      (hd0,3)
kernel      /boot/vmlinuz-2.4.27-2-386 root=/dev/hdb4 ro single
initrd      /boot/initrd.img-2.4.27-2-386
savedefault
boot 
</code>
</hidden>

<hidden Comment restaurer Grub avec l'installation de Windows? >
Prendre un cd live (Knoppix par exemple) et booter ton ordi dessus. Montes ta partition ''/'' de ton systeme (par exemple ''/dev/hdaX'') dans ''/mnt''.
<code>
$ mount /dev/hdaX /mnt
</code>
Change le répertoire de root
<code>
$ chroot /mnt
</code>
Lances ''grub-install'' sur le disque de boot, pour que Grub se réinstalle dans le MBR.
<code>
$ grub-install /dev/hda
</code>
Puis sortir:
<code>
$ exit
</code>
Démontage pour faire propre
<code>
cd / ; umount /mnt
</code>
Et reboot de l'ordinateur.
</hidden>

<hidden Comment lancer linux au prompt de Grub? >
Simplement tapez :
<code>
root (hdx,x)
kernel /vmlinuz-[version du kernel] ro root=LABEL=/
initrd /initrd-[version du kernel].img
boot
<code>
Vous pouvez mettre ''/dev/[ma partition]'' si vous n'utilisez pas les labels.
</hidden>


===== Linux en réseau =====

<hidden Comment télécharger de nombreux fichiers à la volée ? >
Placez les urls dans un fichier texte (nommé par exemple pg_dwd), et tapez simplement :
<code>
$ wget -i pg_dwd
</code>
</hidden>

<hidden Comment pinger tous les postes d'un réseau ?  >
Sur un réseau de classe C :
<code>
$ ping -b 192.168.0.255
</code>
L'adresse IP dépend de l'adresse de broadcast du réseau.
Si par exemple vous avez un serveur DHCP qui vous fournit automatiquement une IP, la commande :
<code>
$ ifconfig ethX
</code>
vous donnera l'adresse de broadcast.
</hidden>

<hidden Puis je naviguer sur le web en mode console ?  >
Oui. Vous pouvez utiliser Lynx (présent dans la plupart des distributions), ou encore [[http://www.w3m.org/|w3m]].
</hidden>

<hidden Comment faire une passerelle minimum sous Linux? >
Mettez dans un script au démarrage (par exemple : ''/etc/rc.local'')
<code>
#Active le forwarding dans le kernel 
echo 1 > /proc/sys/net/ipv4/ip_forward                
# Efface les règles actuelles 
iptables -F                                           
# idem 
iptables -t nat -F                                    
# Active le routage vers ppp0
iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE  
</code>
</hidden>

<hidden Trouver son adresse IP en ligne de commande >
Voici diverses méthodes pour récupérer uniquement l'adresse IP en ligne de commande, utile pour intégrer dans un script. Si vous avez une interface Ethernet :
<code>
$ ifconfig eth0 | grep inet | cut -d":" -f2 | cut -d" " -f1
</code>
Si vous avez une interface PPP :
<code>
$ /sbin/ifconfig | grep "P-t-P" | sed "s/^[: a-z]*\([.0-9]*\).*/\1/"
</code>
Pour trouver l'adresse de la passerelle :
<code>
$ user@host:~$ awk '/eth0/{print $1}' /proc/net/arp 
192.168.0.101 
<code>
Ou bien (toujours pour la passerelle) :
<code>
$ grep $(awk '/\t0003\t/{print $1}' /proc/net/route) /proc/net/arp | cut -d ' ' -f 1 
<code>
Ou encore :
<code>
$ grep $(netstat -arn |grep UG |awk '{ print $8 }' ) /proc/net/arp |awk ' {  print $1 }'
</code>

</hidden>

<hidden Comment connecter deux machines en rsh ? >
Depuis la machine A, je veux une connexion rsh vers une machine B pour un user. Entre les deux machines, il est important d'avoir le même UID pour le user. \\

Configurer la machine B: 
  * Dans le répertoire home du user, créer un fichier .rhosts (700 au niveau des droits) contenant
<code>
machineA mon_user
</code>
  * Dans ''/etc/hosts'', rajouter la machineA
<code>
x.x.x.x    machineA
</code>
  * Dans (x)inetd, décommenter ou rajouter le service rsh et rlogin
<code>
shell  stream tcp  nowait root   /usr/sbin/tcpd       in.rshd
</code>

Configurer la machine A: 
  * Dans ''/etc/hosts'', rajouter la machineB
<code>
y.y.y.y   machineB
</code>

Tester la connexion :
  * Lancer une commande depuis la machine A:
<code>
$ rsh machineB "hostname"
</code>
Si le hostname de la machine B apparait, c'est bon.
</hidden>

<hidden Je n'arrive pas a surfer, comment faire un premier diagnostic ? >
Voici dans l'ordre la liste des opérations pour diagnostiquer. Suivant leurs succès/échec, vous pouvez ainsi en déduire votre problème. Si vous utilisez un proxy, vérifier que votre navigateur est bien configuré pour passer par le proxy. Pour vous assurez que c'est votre navigateur qui pose problème, essayez :
<code>
$ ping www.google.com
</code>
Si le ping est bon, alors c'est le navigateur. Sinon, afficher ''/etc/resolv.conf''
<code>
$ more /etc/resolv.conf
</code>
Vérifier que la ligne
<code>
nameserver x.x.x.x
</code>
contient bien l'adresse ip du serveur DNS de votre FAI. Modifiez la ligne, le cas échéant et recommencez le ping www.google.com
Si le fichier est bien renseigné, faites un
<code>
$ ping 216.239.57.104
</code>
C'est l'adresse IP de google. Le ping est bon, alors tout va bien, vous avez bien un accès au web. Vérifiez l'adresse dns et le fichier ''/etc/resolv.conf''\\

Votre ping ne passe pas? La connexion n'est pas établie. Vérifier votre configuration ethernet, adresse ip/passerelle grâce à la commande ifconfig. Faites un ping de votre passerelle :
<code>
ping x.x.x.x
</code>
Si ce ping passe bien mais le ping de 216.239.57.104 alors votre problème se trouve au niveau du routeur.
</hidden>

<hidden A quoi servent les fichiers /etc/hosts et /etc/host.conf ? >
  * ''/etc/hosts'' contient une liste d'association nom de machine - adresse IP permettant de bypasser la résolution de nom classique (qui interroge les serveurs DNS) pour quelques serveurs dont on connaît l'adresse. Typiquement utilisé pour renseigner des noms de machines locales, plus facilement accessibles par leur nom qu'en tapant l'adresse complète. Le format du fichier est très simple :
<code>
127.0.0.1    localhost.localdomain    localhost
192.168.1.11    mamachine
192.168.1.12    monpc    lepc
</code>
En première colonne l'adresse de la machine, ensuite en 2e colonne (séparée par un espace ou une tabulation) le nom correspondant, suivi éventuellement par ses alias.

  * ''/etc/host.conf'' définit la séquence de recherche pour la résolution de nom. En général on trouve ceci :
<code>
order hosts,bind
multi on
</code>
Cela signifie que le résolveur commencera par chercher dans le fichier /etc/hosts, puis interrogera le DNS. Le multi on veut simplement dire que le résolveur renverra toutes les adresses qu'il trouve pour un nom inscrit dans le fichier hosts, et non seulement la première. C'est l'option par défaut sous Debian et sans d'autres distributions aussi.
</hidden>

<hidden Comment se connecter en ssh sans mot de passe ? >
Le but de l'opération est que l'utilisateur A de la machine Source se connecte comme utilisateur B de la machine Destination. L'opération est un transfert de clé publique entre votre Source et votre Destination.  Sur la SourceEn tant qu'utilisateur A, vous devez générer une paire de clé RSA privée/publique :
<code>
$ ssh-keygen -t rsa -b &gt nombre de bits de la clé &lt -N ""
</code>
Il est conseiller d'utiliser 4096 pour la complexité de la clé.  Deux fichiers sont apparus dans ~/.ssh :
  * id_rsa correspond à la clé privée 
  * id_rsa.pub correspond à l'autre clé, celle publique. 

Sur la DestinationLa clé publique va être recopié sur la Destination dans ~/.ssh/authorized_keys.  Vous avez un fichier dans le format suivant:
<code>
$ ssh-rsa &gt la clé publique&lt A@Source
</code>
Maintenant depuis la machine Source en utilisateur A, il vous suffit de faire :
</code>
$ ssh B@Destination
</code>
</hidden>

<hidden Comment accéder à plusieurs reseaux Ethernet avec une seule carte physique ? >
Linux accepte la création d'interfaces réseaux virtuels de manière simple, il suffit de configurer une carte eth0:1. Exemple:
<code>
$ /sbin/ifconfig eth0:1 192.6.1.23 broadcast 192.6.1.255 netmask 255.255.255.0
</code>
Ceci autant de fois que l'on désire d'interfaces différentes.
</hidden>

<hidden Comment réinitialiser la connexion à internet ou au réseau ? >
Outre les outils graphiques qui peuvent être inclus dans votre distribution, la désactivation et l'activation d'une interface réseau se font respectivement par les commandes ifdown et ifup, en passant en argument le nom de l'interface.  L'interface pour un modem se nomme ppp0, pour une carte réseau eth0. Ainsi, pour réinitialiser la connexion du modem, cela donne :
<code>
$ /sbin/ifdown ppp0
$ /sbin/ifup ppp0
</code>
Pour connaître quelles sont les interfaces réseau sur votre machine, y compris les non actives :
<code>
$ /sbin/ifconfig -a
</code>
</hidden>


=====  Développement =====

<hidden Comment compiler un programme C/C++ sous Linux ? >
Programme C :
<code>
$ cat fichier.c
#include <stdio.h>

int main()
{
printf("Hello world !\n");
return 0;
}
$ gcc -o programme fichier.c
$ ./programme
Hello world !
$
</code>
Programme C++ :
<code>
$ cat fichier.cpp
#include <iostream.h>
 
int main()
{
cout << "Hello world !" << endl;
return 0;
}
$ g++ -o programme fichier.cpp
$ ./programme
Hello world !
$
</code>
L'option -o utilisée par gcc et g++ permet de spécifier le nom de l'exécutable.

</hidden>

<hidden Comment ajouter les informations de débugage à gcc ? >
Il faut compiler le projet avec l'option -g (il est important de passer tous les fichiers en argument), puis de lancer gdb. A noter qu'il existe également un débuggeur graphique : ddd (Display Data Debugger), normalement présent sur votre distribution.
</hidden>

<hidden Qu'est ce que make, un makefile ? >
Les sources d'un programme peuvent comprendre beaucoup de fichiers, incorporer des librairies, etc. Taper à la main les lignes de compilation de chacun des fichiers peut donc devenir très fastidieux. Pour simplifier les compilations de projets sous Unix, il existe l'utilitaire make : il permet d'interpréter un fichier de dépendance entre les différents éléments nécessaires à la création d'un projet. Ce fichier est appelé Makefile.\\

Un makefile définit les relations entre des fichiers, et établit les dépendances nécessaires à la création d'autres fichiers. Si, pour créer un fichier A, il faut utiliser un fichier B, alors il va d'abord falloir créer le fichier B. Le travail de make est essentiellement de vérifier les dates des fichiers pour déterminer quels sont ceux qui sont à jour et ceux qu'il faut recréer afin de générer le projet. Pour chacun des fichiers à recréer, make détermine, grâce au makefile, les librairies à lier, et les arguments à passer à gcc puis lance la compilation. \\

Make simplifie beaucoup le travail du programmeur, puisqu'au lieu de taper les argument de gcc à chaque compilation, il suffit de lancer make. En général, les fichiers makefile contiennent une cible nommée all, qui permet de générer tout le projet. Make peut aussi être utilisé dans un autre contexte que la programmation : il permet d'effectuer des commandes de mises à jour de fichiers qui dépendent de la mise à jour d'autres fichiers.
</hidden>

<hidden Comment ne plus mettre le ./ pour l'execution d'un code après compilation? >
Ajouter dans .bashrc la ligne.
<code>
PATH=$PATH:. 
</code>
et lance un nouveau terminal. Ainsi, en cherchant le programme demandé dans chaque répertoire de la variable d'environnement PATH, le shell va trouvé ce programme dans le répertoire courant (le répertoire .)
</hidden>

<hidden Comment installer une JVM de Sun sous Linux? >
Pour tous les codeurs Java qui aiment leur pingouins, voici la méthode qui leur permettra de télécharger et installer le JDK sous Linux : 
  * 1. Téléchargez le JDK de Sun. 
  * 2. Attribuez-lui le droit d'être exécuté
<code>
$ chmod +x NOM_DE_VOTRE_JDK 
</code>
  * 3. Exécutez-le et installez de ce fait votre JDK. 
  * 4.Attention, c'est là que ça devient chaud. Il va vous falloir configurer 2 variables globales importantes : ''PATH'' et ''CLASSPATH''. Ouvrez votre fichier .bashrc (situé dans votre home) et ajoutez les lignes suivantes :
<code>
export PATH=$PATH:.:/chemin/de/votre/JDK/bin 
export CLASSPATH=.:/chemin/de/votre/JDK/lib/tools.jar 
</code>
  * 5. C'est fini ! 

NB : pour ceux qui veulent généraliser PATH et CLASSPATH pour tous leurs utilisateurs, éditez les 2 lignes mentionnées dans ''/etc/profile''. 

A partir de la version 1.5 Tiger, il n'y a plus à s'occuper de CLASSPATH.
</hidden>

<hidden Comment créer un fichier pipe ? >
Un fichier pipe permet (entre autres) de faire dialoguer plusieurs processus entre eux sans pour autant générer par exemple des fichiers temporaires.
<code>
$ mknod /tmp/fichier_pipe p
</code>
ou
<code>
$ mkfifo /tmp/pipe
</code>
</hidden>