Sommaire.

> Présentation du système d’exploitation libre GNU/Linux.

> Introduction au shell.

> Le système de fichiers.

> Les runlevels.

> Les droits des utilisateurs.

> Le réseau.

> Introduction à Samba.

> Installation de logiciels.

> Infos sur le système.

> Recompiler le noyau.

> Sécuriser le système.

> Trucs et astuces.

> Configuration de Lilo.

> Les bases de l’éditeur Vi.

> Les bases d’Emacs.

> Les bases de GCC.

> Rappel des principales commandes.

> Liens utiles.

> Glossaire.

Présentation du système d’exploitation libre GNU/Linux.

C’est en 1984 que Richard M. Stallman (RMS), alors chercheur au MIT (Massachussetts Institute of Technology, grand centre de recherche américain, dans des domaines très divers), lance le projet GNU (Gnu’s Not Unix, acronyme récursif) en réaction à la mentalité d’alors, qui consiste à garder son code source secret et faire payer des licences pour ses logiciels.

Il souhaite développer un système d’exploitation basé sur Unix, mais totalement libre (il est l’auteur d’Emac, du compilateur GCC...). Il créé pour cela la F.S.F. (Free Software Foundation), pour récolter de l’argent pour ce projet.

Ce qu’il souhaite développer grâce à ce projet est la liberté :

- d’utiliser le programme quel qu’en soit l’usage.

- d’étudier le fonctionnement du programme, et de l’adapter à ses propres besoins.

- de le redistribuer (aider son prochain).

- d’améliorer le programme et de publier ses améliorations, pour que tout le monde puisse en profiter.

Un des points fondamentaux à tout ceci est l’accès au code source.

Linux s’est naturellement associé au projet GNU, car le noyau voulu par GNU n’était pas encore prêt.

Le projet GNU a défini une licence pour garantir toutes ces libertés, la GPL (General Public Licence), qui est très utilisée dans le monde du Libre.

Il existe aussi la licence BSD, compatible GNU mais tirée du projet BSD (un autre Unix libre), et la FDL (Free Documentation licence) qui vient du projet GNU, et qui s’applique à la documentation.

En 1985, RMS crée la FSF (Free Software Fondation), pour s’assurer la logistique nécessaire à son projet. Ce sont surtout des volontaires qui travaillent dessus, à travers le monde entier.

Le mot Linux pour désigner une distribution est un abus de langage, car Linux ne désigne en fait que le noyau, le reste étant en grande partie tiré du projet GNU, c’est pourquoi je parle de GNU/Linux. Les composants du système d’exploitation sont :

- le noyau, le coeur du système.

- les composants GNU : le shell, le compilateur, Emac...

- l’environnement graphique.

- les logiciels serveurs.

Mais le noyau officiel du projet GNU n’est pas Linux, mais le Hurd (qui est un microkernel, contrairement à Linux qui est plutôt monolithique).

GNU/Linux date de 1991. En effet, c’est le 5 octobre 1991 que Linus Torvalds, étudiant Finlandais de 21 ans, annonce sur le forum usenet la mise à disposition des sources d’un système d’exploitation, tout petit pour le moment. Il l’a créé seul, au départ pour ses propres besoins.

Il s’est basé sur Minix, un petit clone d’Unix, libre.

Et GNU/Linux est resté un système d’exploitation libre, librement redistribuable.

GNU/Linux est donc basé sur Unix, qui lui date des années 70, créé dans les laboratoires de AT&T. La première version d’Unix date de 1969, il était alors écrit en assembleur (langage machine). En 1973, il est réécrit en C, puis distribué, avec ses sources, dans les universités.

De nombreuses versions d’Unix vont alors voir le jour en quelques années, qui donneront plusieurs branches : la famille des BSD, les GNU/Linux.

GNU/Linux ressemble beaucoup à Unix (beaucoup de leurs commandes sont équivalentes), il en a les avantages : fiabilité, stabilité, performances.

GNU/Linux, est un système d’exploitation Multi-Utilisateurs, chacun ayant ses propres fichiers, applications et environnement de travail, inaccessibles aux autres.

Il est aussi multi-tâches, il gère très bien le réseau (très utilisé en tant que serveur Internet par exemple), et il est plus sécurisé que la plupart des autres systèmes.

La première version officielle de GNU/Linux date de 1993.

GNU/Linux s’étant beaucoup développé, il intéresse aussi les entreprises, et il existe un nombre impressionnant de logiciels libres pour lui.

Lorsque l’on installe un système GNU/Linux standard, il est fournit dès le départ avec une kyrielle de logiciels qui comblent tous les besoins.

Le logo de Linux, le pingouin, date de 1996, et il s’appelle Tux.

Après ce petit historique, voyons quelques détails du fonctionnement de GNU/Linux :

Les partitions pour pouvoir installer le système sont ext2, ext3 ou Reiser (ce sont les systèmes de fichiers) et une swap (partition d’échange, d’environ 2 fois la taille de la mémoire vive).

Avec ces systèmes de fichiers, il n’y a pas besoin de faire de défragmentation de disque, comme avec d’autres systèmes.

Contrairement à d’autres systèmes d’exploitation, sur celui-ci, tout est fichier ; que ce soit les périphériques, disques durs ou lecteurs amovibles, ils sont tous considérés comme des dossiers.

Une distribution de GNU/Linux est fournit avec les sources du kernel.

Cela permet de compiler son noyau, pour l’adapter à ses propres besoins, pour y ajouter des fonctionnalités ou en retirer certaines qui prennent de la place inutilement. On peut aussi installer un nouveau noyau, pour upgrader son système.

Il existe un grand nombre d’environnements de bureau, mais, les deux principaux sont KDE et Gnome.

Toutes les commandes dont il est question dans ce document sont à effectuer dans une console, souvent avec le compte root (su, puis mot de passe super utilisateur).

Pour avoir l’aide de ces commandes, taper : man commande, ou aussi info commande.

Introduction au shell.

Le shell est un interpréteur de commandes, c’est une interface entre le système d’exploitation et l’utilisateur. Il reçoit les commandes que l’on saisi et les exécute, si on a les droits nécessaires.

Car, lorsque l’on ouvre une session sur le système (qu’on se logue), avec son nom d’utilisateur (login) et son mot de passe, le shell, avant de se lancer, vérifie si le compte est valide, nos droits et nos permissions sur les fichiers, puis charge notre environnement personnel (chaque processus a lui aussi ses propres droits et permissions).

Certaines variables de cet environnement peuvent être modifiées, adapter à nos besoins. Il faut taper stty -a (qui signifie set teletype, c’est à dire configurer le téléscripteur, puisque le shell date des débuts d’Unix et que la plupart des postes étaient alors des terminaux) pour visualiser et modifier ces variables. Sinon, elles sont aussi accesible par le fichier /etc/profile.

Il existe aujourd’hui de nombreux shell, le plus ancien (à l’origine de GNU/Linux) est le shell sh (Bourne Shell) créé dans les laboratoires de AT&T.

Celui fournit en standard sur les systèmes est le shell Bash (Bourne Again Shell), mais il en existe d’autres : Zsh, Korn Shell, le shell C... Ils ont chacun leurs spécificités.

Pour avoir de l’aide, il y a les pages de man, ainsi que la commande help.

Pour connaître votre shell, tapez :

echo $SHELL

Ce qui commence par $ indique qu’il s’agit d’une variable, et echo demande de l’afficher.

Une commande shell se présente ainsi :

commande -option(s) paramètres (optionnel)

Bref introduction sur la programmation shell.

Le shell est aussi un véritable language de programmation, très utile pour automatiser des tâches répétitives ou fastidieuse. Il est très utile pour l’administration système car il permet de fair e beaucoup de choses.

On peut se servir d’un simple éditeur de texte pour faire des scripts shell, tel Kwrite.

Tous scripts shell commencent par la ligne # !/bin/bash, cela indique que l’on utilise le shell bash, ils acceptent des paramètres que l’on peut récupérer dans le script. L’extension du fichier créé sera sh, et il faut le rendre exécutable (chmod a+x prog) pour pouvoir le lancer simplement avec ./prog.

Les commentaires se notent #, on déclare une variable comme cela : var=valeur, et on l’affiche en faisant : echo $var.

Il a plusieurs métacaractères, comme par exemple [!0-9] qui désigne tous caractères n’étant pas un chiffre.

cmd1 && cmd2 permet d’exécuter cmd2 uniquement si cmd1 s’est terminée correctement, inversement avec ||.

Les pipes | permettent de rediriger une sortie standard vers l’entrée d’une autre commande, c’est très pratique.

Il y a évidemment les if, while, case, until...

Voilà, ce n’est qu’un bref aperçut des grandes possibilitées qu’offre la programmation shell.

Voici quelques commandes utiles pour les scripts shell :

Redirections :

> : redirection de la sortie standard.

2> : redirige seulement les messages d’erreur ;

2>&1 : permet de rassembler la sortie standard et la sortie d’erreurs.

< : redirection en entrée.

Jokers avancés :

[a] signifie : égal à ’a’.

[!a] signifie : différent de ’a’.

[abc] signifie : l’un des caractères a, b ou c.

[a-l] : signifie : tous les caractères compris entre a et l.

Les différentes expressions régulières sont :

^ début de ligne

. un caractère quelconque

$ fin de ligne

x* zéro ou plus d’occurrences du caractère x

x+ une ou plus occurrences du caractère x

x ? une occurrence unique du caractère x

[...] plage de caractères permis

^{...] plage de caractères interdits}

\ n\ pour définir le nombre de répétition n du caractère placé devant

La commande grep permet de rechercher une chaîne de caractères dans un fichier.

-v affiche les lignes ne contenant pas la chaîne

-c compte le nombre de lignes contenant la chaîne

-n chaque ligne contenant la chaîne est numérotée

-x ligne correspondant exactement à la chaîne

-l affiche le nom des fichiers qui contiennent la chaîne

Recherche de fichier :

find

-name recherche sur le nom du fichier,

-perm recherche sur les droits d’accès du fichier,

-links recherche sur le nombre de liens du fichier,

-user recherche sur le propriétaire du fichier,

-group recherche sur le groupe auquel appartient le fichier,

-type recherche sur le type (d=répertoire, c=caractère, f=fichier normal),

-size recherche sur la taille du fichier en nombre de blocs (1 bloc=512octets),

Trier un fichier avec sort :

-b ignore les espaces et les tabulations en début de champ

-d tri sur les caractères alphanumériques (caractères, chiffres et espace) uniquement

-r inverse l’ordre de tri

-f pas de différence entre minuscule et majuscule

-tx Le caractère x est considéré comme séparateur de champ

-u supprime les lignes doublons

-n trie sur des chiffres

Compter les lignes d’un fichier : wc

La commande wc permet de compter le nombre de ligne d’un fichier, mais aussi le nombre de mot ou de caractères.

wc -l mon-fichier

Pour avoir le nombre de mot l’option est -w, -c compte le nombre de caractères.

Sans options, elle donne le nombre de ligne, de caractères et de mots.

Edition de champ d’un fichier : cut

La commande cut permet d’extraire certains champs d’un fichier. Les options sont les suivantes :

-c extrait suivant le nombre de caractères

-f extrait suivant le nombre de champs

-dx Le caractère x est le séparateur de champ

cut -c-10 fichier : extrait les 10 premiers caracteres de chaque ligne

cut -d : -f6 /etc/passwd

affichera le 6eme champ du fichier /etc/passwd, dont le séparateur de champs est le caractére double point.

cat permet d’afficher un fichier à l’écran, sur la console.

cat -n affiche les numéros de ligne.

head affiche, par défault, les 10 premières lignes d’un fichier.

tail affiche les 10 cernières lignes d’un fichier.

more affiche un fichier à l’écran, page par page.

Le système de fichiers.

Sous GNU/Linux, tous les fichiers, périphériques, disques durs sont considérés comme des dossiers

L’arborescence.

/binFichiers exécutables des commandes systèmes principales.

/bootNoyau et fichiers de démarrage.

/devFichiers spéciaux, points d’entrées des périphériques.

/etcFichiers de configuration du système ainsi que les principaux scripts de paramétrages.

/homeContient les répertoires des utilisateurs, ce dossier peut être une partition à part.

/libBibliothèques système.

/mntRacine des points de montage (pour lecteur de Cd-rom, disquette, partage windows).

/optInstallation de packages supplémentaires.

/rootRépertoire personnel du super-utilisateur.

/sbinBinaires systèmes pour l’administration.

/tmpFichiers temporaires.

/usrProgramme accessibles à tous les utilisateurs, c’est une sous-arborescence.

/varDonnées variables.

/proc« image » du système.

Même si l’arborescence se présente toujours comme cela, les dossiers (/tmp, /home, /usr) peuvent être situés sur d’autres partitions.

Nommage des partitions et des périphériques.

Les disques durs sont nommés hda pour le premier, hdb et ainsi de suite. Les différentes partitions sont ensuites numérotées : hdb2 serait donc la deuxième partition du deuxième disque dur.

Les lecteurs de disquettes sont nommés fd0, fd1... (dans /dev/...).

Tous les périphériques (cd-rom, disquettes, partitions...) sont dans le répertoire /dev, et ils sont en général montés dans le répertoire /mnt (/mnt/cdrom, /mnt/floppy, /mnt/windows).

Montage des partitions et des périphériques.

Pour pouvoir travailler sur un cd-rom, une disquette, un dossier partagé, il faut tout d’abord le monter, pour qu’il soit accessible.

Pour cela, on utilise la commande mount. Elle a besoin de plusieurs arguments, dont, le périphérique à monter, le point de montage (l’endroit où vous souhaiter monter le périphérique), le système de fichier (ext3, vfat, ntfs, smb...), et certaines options.

Inversement, pour démonter une partition, c’est la commande umount qu’il faut utiliser.

Par exemple, pour monter un lecteur de cd-rom, il faut taper :

mount /mnt/cdrom

Pour le démonter :

umount /mnt/cdrom

Et pour l’éjecter, il faut faire :

eject /mnt/cdrom

Pour une partition :

mount /dev/hda1 /mnt/windows

Toutes les partitions et périphériques que l’on peut monter sont configurables grâce au fichier /etc/fstab. Il est préférable d’utiliser ce fichier plutôt que de monter à chaque fois telle ou telle partition.

Voici un exemple de fichier /etc/fstab, qui monte un lecteur de CD-ROM, un graveur de DVD, un lecteur de disquette, une parttion win..., et les parttions GNU/Linux :

/dev/hda3 / ext3 defaults 1 1

none /dev/pts devpts mode=0620 0 0

/dev/scd0 /mnt/cdrom auto user,iocharset=iso885915,codepage=850,noauto,ro,exec 0 0

/dev/scd1 /mnt/cdrom2 auto user,iocharset=iso885915,codepage=850,noauto,ro,exec 0 0

/dev/fd0 /mnt/floppy auto user,iocharset=iso885915,sync,codepage=850,noauto,exec 0 0

/dev/hda1 /mnt/windows ntfs iocharset=iso8859-15,ro 0 0

none /proc proc defaults 0 0

/dev/hda2 swap swap defaults 0 0

/dev/scsi/host0/bus0/target1/lun0/cd /mnt/cdrom2 auto ro,noauto,user,exec0 0

/dev/scsi/host0/bus0/target0/lun0/cd /mnt/cdrom auto ro,noauto,user,exec0 0

Les runlevels. 

Sous GNU/Linux, le système peut démarrer sous différents runlevels (niveau d’exécution) :

0 Arrêt

1 Mode mono-utilisateur (maintenance système, failsafe).

2 Mode multi-utilisateurs, sans réseau.

3 Mode multi-utilisateurs, réseau, sans environnement graphique, donc en console.

4 Non utilisé

5 Mode multi-utilisateurs, réseau et environnement graphique.

6 Redémarrage.

grep :initdefault /etc/inittab

Renvoie le runlevel du système.

Le niveau d’exécution peut être modifié :

- lors du boot,

- par le fichier /etc/inittab,

- par la commande init niveau.

Les services sont lancés par des scripts dans /etc/init.d. Les fichiers stockés dans /etc/rc.d, avec des numéros correspondants aux runlevels (rc1.d à rc6.d), servent aussi à lancer les services, suivant leur runlevel.

Chaque service démarre à son propre runlevel, que l’on peut modifier.

/etc/init.d/service start/stop/restart/status

Permet d’agir sur le service voulu.

chkconfig -list

Liste tous les services pour connaître leur niveau d’exécution.

chkconfig -level 0123456 nom_service off / on

Active ou désactive le service voulu.

chkconfig -add service

Ajoute un service au démarrage.

Les droits de utilisateurs.

Les utilisateurs sous GNU/Linux.

L’utilisateur root (super-utilisateur) a tous les droits sur le système, et peut faire tout ce qu’il veut. Il faut donc utiliser ce compte avec parcimonie.

Il faut créer des utilisateurs, qui auront, eux, des droits plus réduits et seront donc moins « dangereux » pour le système.

Chaque utilisateur aura ensuite ses propres fichiers dans son propre répertoire (sans avoir accès aux répertoires des autres utilisateurs), et ne pourra lancer que certains programmes, dépendants du groupe auquel il appartient ou des droits que le root (l’administrateur du système) lui aura accordés.

Quand un utilisateur se log, le script /etc/profile s’exécute, puis recherche le fichier .bash_profile ou .profile, où l’on stocke les variables d’environnement de cet utilisateur (par exemple, les alias).

La commande sudo permet à un utilisateur, autorisé par root, à obtenir temporairement (par tranche de 5 min) les droits de root. Il faut pour cela configurer le fichier /etc/sudoers pour y ajouter les personnes autorisées.

Pour créer un utilisateur, il faut se servir de la commande :

adduser utilisateur 

Et ensuite créer son mot de passe (ne jamais laisser un compte sans mot de passe !) :

passwd utilisateur

On peut ensuite regrouper des utilisateurs dans différents groupes, qui auront chacun des droits différents.

Modification des droits sur les fichiers.

Il existe 5 types de fichiers sous GNU/Linux :

Les fichiers ordinaires représentés par un -

Les fichiers spéciaux en mode bloc b

Les fichiers spéciaux en mode caractères c

Les répertoires d

Les liens symboliques l

Pour pouvoir agir sur un fichier, il faut pour cela avoir les droits nécessaires, ou modifier ses droits pour un fichier précis.

Ceci se fait grâce à la commande :

chmod paramètres fichier

Les paramètres peuvent êtres écrit de manière symbolique (en lettres) ou octal (avec des chiffres).

Les droits d’un fichier se présentent comme ceci :

roman.txt - rwx -x -x

Comme vous le voyez, le premier symbole correspond au type du fichier, ici un fichier standard, et ensuite, les droits de ce fichier, découpé en 3 parties, elles-mêmes découpées en 3 accès différents :

Les 3 premières lettres correspondent aux droits du propriétaire, ensuite le groupe, et les 3 derniers, tous les autres utilisateurs.

Le r signifie des droits de lecture (read), le w donne les droits d’écriture (write), et le x donne les droits d’exécution.

Les paramètres de chmod sont :

A qui donner les droits :

a : tous les utilisateurs.

g : le groupe du propriétaire.

o : tous les utilisateurs, sauf ceux du groupe.

u : uniquement à l’utilisateur.

Les opérateurs pour ajouter ou enlever des permissions :

+ : ajoute les droits.

- : soustrait des droits.

Les droits :

x pour exécuter.

r pour lire.

w pour écrire.

Le réseau.

Les cartes réseaux sont nommées eth0, eth1... et Io pour la boucle locale (127.0.0.1).

Les fichiers principaux de configuration du réseau (que l’on peut modifier avec un simple éditeur de texte) sont :

Le fichier /etc/hosts :

Pour affecter l’adresse IP et le nom d’hôte de la machine.

Le fichier /etc/networks :

Celui-ci permet de gérer les sous réseaux, en général, il n’a pas besoin d’être modifié.

La commande hostname permet d’afficher votre nom d’hôte.

Quelques commandes utiles pour gérer le réseau :

ifconfig :

Cette commande permet de connaître la configuration de sa carte réseau et de la modifier si besoin est.

Ifconfig IP interface pour affecter IP à interface.

Par exemple :

ifconfig 192.168.0.1 eth0 affecte l’adresse 192.168.0.1 à la carte réseau eth0.

/sbin/route :

Pour afficher ou modifier la table de routage du noyau. On lui indique par exemple la passerelle pour se connecter à internet.

netstat :

Affiche la liste des ports en écoute, ainsi que les protocoles et connexions actives.

Introduction à Samba.

Le serveur Samba, qui date de 1987, est un serveur de fichiers, très souvent fournit en standard sur les diverses distributions GNU/Linux.

Il utilise le protocole SMB (Server Message Bloc). C’est un programme qui fonctionne en mode client / serveur, et qui permet de partager des dossiers, répertoires, imprimantes entre des machines en réseau, qu’elles tournent sous GNU/Linux ou Win...

La partie serveur est composée de deux daemons : smb, le coeur du serveur, et nmbd qui fournit les services.

Le client est smbclient.

Le fichier de configuration se trouve généralement dans /etc/samba et s’appelle smb.conf.

Il est composé de plusieurs sections, pour la configuration du réseau, de la sécurité, des utilisateurs, des différents partages. Voici un petit aperçu de ce fichier :

#=======================GlobalSettings==========================

[global]

# 1. Server Naming Options :

# workgroup = NT-Domain-Name or Workgroup-Name

workgroup = linux

# netbios name is the name you will see in "Network Neighbourhood",

# but defaults to your hostname

netbios name = Tux

# server string is the equivalent of the NT Description field

server string = Samba Server

 ;[public]

 ; path = /usr/somewhere/else/public

 ; public = yes

 ; only guest = yes

 ; writable = yes

 ; printable = no

 ;[fredsprn]

 ; comment = Fred’s Printer

 ; valid users = fred

 ; path = /homes/fred

 ; printer = freds_printer

 ; public = no

 ; writable = no

 ; printable = yes

Pour lancer/arrêter/voir l’état de samba :

/etc/init.d/smb start/stop/status

Pour vérifier que le fichier de configuration est correct, faite :

testparm /etc/smb.conf hostname

Pour voir les dossiers partagés par samba :

smbclient -L hostname

Accéder à un dossier en partage sous Win... :

Créer un dossier, dans /mnt par exemple, puis, dans une console :

smbmount //host_distant/fichier_à_récupérer /mnt/dossier_dans_mnt

Installation de logiciels.

Avec une installation standard de GNU/Linux, de nombreux logiciels sont fournis, et pour tous les besoins, que ce soit la bureautique (OpenOffice, Koffice), le multimédia (Xmms, noaturn, Xine...), internet (Mozilla, Galeon...), des éditeurs de texte, des outils de programmation et bien d’autres encore.

Les programmes sous GNU/Linux se présentent soit en fichier compressé (archive .tar, .gz, ...), soit en .rpm (redhat package manager).

Tout d’abord, les rpm :

C’est un format standard sous Linux. Il suffit tout d’abord de télécharger le programme voulu (un package), puis ensuite de l’installer grâce aux commandes suivantes, que l’on saisi dans une console, après être allé dans le répertoire où est le package :

rpm -ivh programme.rpm

Pour installer un package.

rpm -Uvh programme.rpm

Pour mettre à jour.

rpm -e programme

Pour supprimer un package.

rpm -qa

Lister les packages installés.

Puis les archives :

Souvent au format .tar.gz ou .tar.bz2.

Comme les rpm, il faut se placer dans le répertoire où est l’archive, et taper dans une console :

tar xvf archive.tar

Décompresse une archive .tar.

gunzip archive.gz

Décompresse une archive .gz.

bzip2 -d archive.bz2

Décompresse une archive .bz2.

tar zxvf archive.tar.gz

Décompresse une archive .tar.gz.

tar jxvf archive.tar.bz2

Décompresse une archive .tar.bz2.

Une fois l’archive décompressée, pour installer le programme, il faut taper les commandes suivantes, dans son répertoire (mais lisez les fichiers readme ou install pour de plus amples informations sur la façon d’installer ou de configurer tels ou tels logiciels) :

./configure

make

make install

Informations sur le système.

Voici quelques commandes pour se renseigner sur son système :

arch

Permet de connaître l’architecture de son système (i386, i686, ppc...).

uname -r

Permet de connaître la version du noyau.

top

Permet de savoir quels sont les processus en cours, la mémoire, l’usage du processeur.

ps -aux

Permet de voir tous les processus qui tournent, ainsi que leur PID (Process ID, numéro d’identification d’un processus actif, le premier lancé sous GNU/Linux est le processus init, le « père » de tous les autres processus), leur utilisateur, la commande qui les lance, leur usage mémoire...

df -h

Donne l’utilisation de la mémoire (libre, occupée) sur les partitions montées.

env | more

Affiche les variables d’environnement.

who

Permet de savoir qui est connecté sur le système.

last

Affiche les dernières personnes connectées.

man programme ou commande

Permet d’afficher les pages de man (format standard sous GNU/Linux pour les pages de manuel) d’une commande ou d’un programme.

lsdev

Affiche le matériel installé.

more /proc/cpuinfo

Donne des informations sur le processeur.

scanpci

Pour voir les cartes PCI du système.

/sbin/fdisk -l

Affiche les partitions.

Recompiler le noyau.

La recompilation du noyau peut se faire lorsque l’on désire installer une version du noyau plus récente, ou lorsque l’on souhaite modifier des modules, ajouter de nouvelles fonctionnalités, ou enlever des pilotes non utilisés.

Pour télécharger un nouveau noyau (au format .tar par exemple), le site incontournable est www.kernel.org.

Décompressez l’archive sous /usr/src, ce qui crée un répertoire linux.

Allez ensuite dans ce répertoire (/usr/src/linux), puis utilisez une des commandes suivantes : make config (outil en mode texte), make menuconfig (mode texte mais avec des menus), ou encore make xconfig (menus en mode graphique).

Il y a beaucoup de menus, avec chacun plusieurs sous-menus, alors, je ne les énumérerais pas ici.

Une fois votre configuration finie, cliquez sur save and exit.

Tapez ls -al depuis ce même répertoire. Vous pouvez éditer le fichier Makefile de ce répertoire, et modifier la ligne EXTRAVERSION=2.4.21-nouveau_kernel pour donner un nom compréhensible à votre noyau.

Ensuite, taper make dep clean, make bzImage modules. La deuxième commande compile le noyau, et, normalement, crée un fichier nommé bzImage dans /usr/src/linux/arch/i686/boot.

Tapez ensuite, depuis /usr/src/linux :

cp .arch/i386/boot/bzImage /boot/vmlinuz-2.4.21-nouveau_kernel

Puis : cp System.map /boot/System.map-2.4.21-nouveau_kernel

Ensuite, on installe les modules avec make modules_install.

Toujours depuis /usr/src/linux, faites :

mkinitrd /boot/initrd-2.4.21-nouveau_kernel 2.4.21-nouveau_kernel

Et là, il n’y a plus qu’)à indiquer à Lilo ou Grub qu’il y a un nouveau noyau que l’on souhaiterais pouvoir lancer. Il faut donc configurer l’un des deux pour qu’il puisse lancer ce nouveau noyau (n’effacez pas l’entrée de l’ancien noyau, au cas où le nouveau ne démarrerais pas, mais dupliquez-la et pour la modifier). Pour Lilo, tapez ensuite : /sbin/lilo pour vérifier que la nouvelle entrée est ajoutée correctement.

Il n’y a plus qu’à redémarrer pour vérifier que ce noyau fonctionne.

Sécuriser le système.

Voici quelques conseils pour sécuriser un minimum son poste sous GNU/Linux.

Ce n’est qu’un début car évidemment, les problèmes de sécurité sont complexes et il y aurait beaucoup à faire.

> Lors de l’installation, il faut penser aux programmes que l’on utilisera, et n’installer que ceux nécessaires. Moins il y a de programmes installés, moins il y a de risques.

> Après l’installation, vérifier ce qui a été installé (car certains programmes s’installent par défaut). Il faut aller regarder dans les scripts de /etc/xinetd.d pour voir quelles sont les applications démarrées suivant votre runlevel, et désactiver celles présentant des risques, ou inutiles. Il suffit d’éditer le script du service et de modifier disable.

Pour activer ou désactiver un service au démarrage, faire :

/sbin/chkconfig -level 0123456 service on/off

Il vaut mieux désactiver les services tels que telnet, rwho, finger, httpd, sendmail, netfs, rusersd...

Pour voir la liste de tous les services et leurs statuts, faire :

/sbin/chkconfig —list

> Il faut aussi vérifier les fichiers /etc/passwd et /etc/group pour vérifier qu’il n’y ai pas de compte sans mot de passe.

Il existe un programme (Shadow), qui permet de stocker les mots de passe dans un autre répertoire, et surtout, de les crypter pour qu’ils ne soient accessibles que par le root. Il est donc conseillé d’installer shadow, qui ensuite, se lance comme ceci :

/usr/sbin/pwconv

Pour vérifier que les mots de passe shadow sont activés, éditez le fichier /etc/passwd. S’il y a un x après le nom du compte, c’est que shadow est activé. S’il y a une *, c’est que le compte est désactivé.

> Très important aussi, maintenir son système à jour, en téléchargeant sur le site de l’éditeur les patchs et correctifs (pour le système, mais aussi pour les programmes installés).

> Evidemment, installer (et bien configurer) un firewall, souvent basé sur Iptable, tel shorewall. Et surveiller les ports ouverts, pour vérifier qu’il n’y ai rien d’anormal, avec un scanner tel que Nmap.

> Faire des contrôles de root-kit réguliers avec chkrootkit. Il permet de vérifier la présence de rootkits, des programmes malveillants utilisés par les pirates pour corrompre le système.

> Eviter d’utiliser (et d’installer) les outils en « r » : rlogin, ruser, rsh... car leur authentification est assez faible.

> Utiliser des mots de passe de 6 ou 8 caractères, en utilisant des minuscules, majuscules, symboles et chiffres. Ne pas prendre de mots du dictionnaire.

> Utiliser un programme de vérification d’intégrité du système, tel Tripwire, pour vérifier qu’il n’y ai pas eu de modification du système par un intrus.

> Penser à contrôler régulièrement les fichiers de log (généralement dans /var/log) pour être au courant de tout ce qui se passe sur son système.

> On peut aussi installer un IDS (détection d’intrusion système) afin de pouvoir contrecarrer les tentatives d’intrusion.

> Et enfin, il faut se tenir au courant des évolutions matérielles et logicielles, des nouvelles failles et virus et des moyens de s’en protéger.

Gérer son poste GNU/Linux.

Les tâches d’administration d’un poste font partie des tâches de sécurisation.

Il faut bien gérer les utilisateurs, leurs différents groupes, les droits que chacun a sur les programmes, et aussi, les former sur les problèmes de sécurité.

Penser à réaliser régulièrement des sauvegardes de ses documents, des fichiers de configuration...

Il existe deux outils principaux, souvent fournit en standard, pour gérer et configurer son poste :

Webmin : c’est une interface web qui permet de pratiquement tout configurer.

LinuxConf : outil pratique pour configurer bon nombres de choses sur un poste.

Trucs et astuces.

Voici divers petits trucs à connaître :

> Pour faire un raccourci sur le bureau pour un programme ou une commande (comme par exemble /sbin/reboot) :

Clic droit sur le bureau,

« créer un nouveau »,

« lien vers une application »,

puis remplissez les cases utiles (chemin de l’exécutable, droits pour l’exécution de l’application).

> Pour avoir le lecteur CD-ROM, ou une disquette, une partition en partage sur le bureau :

Clic droit sur le bureau, puis :

« créer un nouveau »,

« CD-ROM » ou « disquette » ou « disque dur ».

> Le pavé numérique ne s’allume pas toujours par défaut au démarrage, alors pour y remédier, il faut tout d’abord vérifier si vous avez le package numlockx. Si oui, faite « numlockx on » dans une console, sinon, il vous faudra l’installer.

> Commandes pour gérer les services :

ksysv ou chkconfig.

> Pour démarrer en mode mono-utilisateur, utile pour faire du dépannage :

linux single au moment du boot.

> Pour rechercher un fichier, utilisez la commande « find » :

find / -name fichier_à_chercher -print

> Pour agir sur un service :

/etc/rc.d/init.d/service start/stop/restart

> Créer un alias pour une commande, si vous l’utilisez souvent, où qu’elle est longue à taper et que l’on a du mal à s’en rappeler :

Par exemple, pour monter le CD-ROM, la commande est :

mount /mnt/cdrom

On peut remplacer ceci simplement par cdrom ou autre chose, en ajoutant dans le fichier /home/bashrc (mais cela dépend de votre shell) :

alias cdrom=”mount /mnt/cdrom”

> Pour rediriger le résultat d’une commande ailleurs que sur la sortie standard (stdout, l’écran, stdin est l’entrée standard, le clavier, et stderr la sortie d’erreur), il suffit d’ajouter > et un nom de fichier par exemple :

ps aux > test.txt

> Si vous avez besoin d’aspirer un site, le votre par exemple pour le sauvegarder utilisez :

wget -m adresse_du_site

> Pour manipuler les modules :

Tout d’abord, les modules, ce sont, en général, des drivers qui sont extérieurs au noyau (pour gagner en place et en « modularité »). Ils peuvent se charger en mémoire soit manuellement, soit automatiquement. Ils se situent souvent dans /lib/modules.

lsmod : affiche les modules chargés à cet instant.

insmod module : charge le module.

rmmod module : décharge le module.

modprob module : charge le module, ainsi que les modules dont il dépend (les dépendances).

> Pour tuer un processus récalcitrant, il faut utiliser la commande kill, et, parfois, kill -9, ce signal ne pouvant être intercepté.

> Pour configurer le serveur X, on peut se servir de xf86cfg ou xf86config. Le fichier de configuration s’apelle XF86Config-4 ou xorg.conf et les deux se situent dans le répertoire /etc/X11.

> Pour créer une disquette de démarage avec Lilo, tapez :

/sbin/mkbootdisk numéro noyau

numéro noyau est récupéré grâce à la commande uname -r.

> Pour mettre à jour les librairies dynamiques, après des mises à jour par exemple, faites /sbin/ldconfig. Cette commande lit le fichier /etc/ld.so.conf, où sont indiqué les chemins des diverses librairies utilisées.

Configuration de Lilo.

Lilo (Linux Loader), est un programme permettant de démarrer GNU/Linux, il en existe d’autres, notamment Grub (Grand Unified Bootloader) qui est aussi très utilisé (et plus puissant).

Il peut se configurer grâce au fichier /etc/lilo.conf, dont voici un exemple :

boot=/dev/hda

map=/boot/map

vga=normal

default="TuX"

keytable=/boot/fr-latin1.klt

prompt

nowarn

timeout=150

message=/boot/message

menu-scheme=wb :bw :wb :bw

image=/boot/vmlinuz-2.4.22mdk

label="TuX"

root=/dev/hda2

initrd=/boot/initrd-2.4.22mdk.img

append="quiet devfs=mount hdc=ide-scsi hdd=ide-scsi acpi=off"

vga=788

read-only

other=/dev/hda1

label="win"

table=/dev/hda

Ce fichier montre qu’il n’y a qu’un disque dur (hda), le système lancé par défaut est Tux, et il y a aussi un système win... sur la première partition du disque (hda1).

Le système est en français (keytable), et il attend 15 secondes (timeout), puis, si aucune touche n’est pressée, il lance GNU/Linux.

Append permet de passer des paramètres au noyau lors du démarrage, ici, par exemple, il faut émuler des graveurs SCSI.

Les bases de l’éditeur Vi.

Vi est un éditeur datant d’Unix, et il est encore présent sur toutes les plateformes GNU/Linux. Il est donc nécessaire d’en connaître les bases, car parfois, il est le seul éditeur disponible.

C’est un éditeur plein écran, il n’y a donc pas d’interface graphique, ni même de menu. Mais il est interactif, car il communique avec l’utilisateur, grâce à la ligne d’état, qui affiche des messages.

Vi possède deux modes différents :

> Le premier, celui qui est actif par défaut à son lancement, est le mode commande. Toutes frappes de l’utilisateur sont interprétées comme des commandes.

> Le mode insertion, lui, interprète chaque frappe comme du texte à ajouter dans le fichier ouvert.

Pour passer du mode commande au mode insertion, il faut taper a (pour ajout) ou i (pour insertion). Inversement, pour quitter le mode insertion, taper esc.

Vi peut être configuré pour s’adapter à l’utilisateur, ceci ce fait par la commande set.

Lorsque l’on démarre Vi, en tapant simplement vi dans une console, ou vi fichier, les lignes vides apparaissent avec un (tilde) en début.

Maintenant, voici quelques commandes de base :

Pour se déplacer dans un fichier, outre les flèches, on peut utiliser h, j, k, l.

Pour faire avancer l’écran, ctrl B.

 :help permet d’obtenir de l’aide.

A : ajoute du texte en fin de ligne.

R : remplace du texte à partir du curseur.

R : remplace un caractère.

O : ouvre une ligne sous la ligne courante pour ajout de texte.

U : permet d’annuler une action.

Maj h : va à la première ligne.

Maj l : va à la dernière ligne.

/mot : cherche mot dans le fichier.

 :n fichier : ouvre fichier.

 :q ! : quitte sans sauvegarder.

 :w : enregistre.

 :wq : enregistre et quitte.

Les bases d’Emacs.

Emacs est un éditeur de texte extrêmement puissant. Il a été écrit par R.M.S (Richard Stalman, fondateur de la Free Software Fundation) entre 1984 et 1985, lorsqu’il travaillait encore au M.I.T.

Le langage utilisé est principalement le Elisp (Emacs Lisp, spécialement conçu pour pouvoir implémenter facilement Emacs, et donc lui ajouter des fonctionnalités), ainsi que le C.

Pour lancer Emacs, tapez simplement son nom dans une console.

Celui-ci est le plus répandu des éditeurs de texte sous GNU/Linux.

Pour se servir d’Emacs, on se sert de combinaisons de touches, par exemple, Ctrl-a, pour aller en début de ligne.

Il existe différents modes pour travailler, des modes majeurs, et dans ces modes, d’autres modes encore, dits mineurs. Par défaut, Emacs essai d’ouvrir un fichier dans le bon mode majeur : un fichier .c sera ouvert dans le mode de programmation C.

Il y a un mode pour les mails, un pour telnet, pour java, lisp évidemment, et bien d’autres encore. Il y a même un mode shell.

Dans chacun de ces modes majeurs, on peut ajouter des modes mineurs : le saut de ligne automatique, la gestion des versions, inclure des abréviations...

On peut paramétrer les combinaisons de touches comme ceci :

(define-key keymap « séquence de touches » ’nom de commande)

(global-set-key « séquence de touches » ’nom de commande)

(local-set-key « séquence de touches » ’nom de commande)

Et pour modifier le contenu d’une variable, on utilise la commande : setq nom_de_variable nouvelle_valeur

Pour ouvrir un fichier avec Emacs, tapez emacs fichier.

Voici maintenant quelques commandes de bases (le C signifie Ctrl, et le M Alt) :

C-p Monter d’une ligne

C-n Descendre d’une ligne

C-a Début de ligne

C-e Fin de ligne

C-v Descendre d’une page

M-v Monter d’une page

C-x C-s Sauvegarde le buffer courant sur le disque

C-x u Annule la commande précédente

C-c C-f Ouvre un fichier

C-x C-c quitte Emacs

C-d M-x Efface le caractère sur lequel est le curseur

M-d M-x Efface le mot à partir du curseur

M-backspace M-x backward Efface le mot précédent

C-k M-x Efface la ligne à partir du curseur

Il existe beaucoup d’autres commandes, car on peut vraiment tout faire avec Emacs, c’est vraiment un environnement de travail complet.

Les bases de GCC.

GCC est le compilateur standard du projet GNU, il a été écrit en grande partie par R.M.S. C’est un logiciel libre, publié sous licence GNU GPL, et fournit sur quasiment tout les systèmes d’exploitation libre (dont GNU/Linux évidemment).

GCC signifiait, au départ, GNU C Compiler, mais au fur et à mesure de son évolution, il compile de plus en plus de language (C++, objective C, fortran, ada, java), donc maintenant cet acronyme veut dire GNU Compiler Collection.

Il s’utilise simplement en ligne de commandes, en tappant :

gcc prog.c 

Faite gcc -help pour voir l’aide.

Pour avoir tous les messages d’erreur d’un programme que vous compilez, faites :

gcc -Wall prog.c prog

Pour nommer le fichier de sortie, qui par défault s’apelle a.out, utilisez l’option -o

Pour pouvoir utiliser GDB, le dégogueur standard du projet GNU, écrit par R.M.S. en 1988, publié lui aussi en GPL, il faut utiliser l’option -g

On compile un programme en C :

gcc -Wall -g -o prog.c prog

Une erreur s’affiche lors de cette compilation, un fichier core est donc créé, dans le répertoire courant, qui contient tous les paramètres du programme lors de son plantage.

C’est grâce à ce fichier que GDB va pouvoir nous indiquer ce qui a provoqué cette erreur.

On tappe alors :

gdb core prog

GDB se lance, on tape la commande where, pour qu’il nous indique où se situe l’erreur, puis, une fois cela fait, on tape quit, pour revenir au shell.

Rappel des principales commandes.

cd .. : remonte d’un niveau.

ls -l : liste les attributs de fichiers.

ls -a : liste aussi les fichiers cachés.

ls -t : liste par date.

cp origine destination : permet de copier un fichier.

cp -i : demande pour éviter l’écrasement de fichiers.

cp -r : copie récursivement le répertoire et ses sous-répertoires.

rm -d : supprime un répertoire, vide ou non.

rm -r : supprime un répertoire et ses sous-répertoires.

mkdir : cré un répertoire.

mv : déplace un fichier.

cat : affiche un fichier.

cat -n : permet de numéroter les lignes.

file : permet de connaitre le type de fichier.

at options time : permet de lancer une commande à un moment précis.

at -c cmd : affiche cmd.

at -d cmd : efface cmd.

crontab : exécution d’une commande à interval régulier.

fdformat : formatte une disquette.

free : affiche la mémoire libre.

mkbootdisk : cré une disquette de démarage.

mount : pour monter un système de fichier (CD-ROM, partition...).

netstat : informations sur la configuration du réseau.

ps : affiche la liste des processus.

tar : archivage de fichiers.

tar -z : décompacte une archive.

tar -t : affiche les fichiers de l’archive.

tar -c : cré une archive.

uname : informations système.

uname -a : affiche toutes les informtions possibles.

uname -i : platform.

uname -n : hostname.

uname -p : processeur.

uname -r : release du kernel.

who : affiche les utilisateurs courants.

dd options : copie suivant certaines options un fichier sur la sortie spécifiée ou la sortie standard.

dd conv=flags : permet de convertir la sortie.

dd if=file  : lit depuis l’entrée spécifiée.

su options users args : permet de lancer un shell pour un autre utilisatuer, ou le root par défault.

sudo options cmd : permet de lancer une commande, si l’on est autorisé, avec les droits du root.

sudo -b : commande en arrière-plan.

sudo -k : enlève la permission.

route options cmd : affiche la table de routage du noyau.

route add adress : ajoute une route.

route del adress : enlève une route.

top : affiche sur la console les processus actif en temps réel.

passw user : change le mot de passe de user.

chkconfig : pour gérer les services et le niveau de démarage.

chmod : modifier les droits des fichiers.

hostname : affiche le nom d’hote, ou le définit.

lpr : inscrit un fichier dans la file d’attente d’impression.

lpc : controle les tâches d’impression.

Liens utiles.

Documentation et news sur GNU/Linux et l’open source :

fr.tldp.org

www.linux-center.org (il y a aussi des programmes).

slashdot.org (en anglais, news sur l’informatique, la programmation et le libre).

linuxfr.org (très bon site, plein d’infos)

www.lea-linux.org (très bon site pour les Linuxiens débutants, il y a tout : progs, tutoriaux, astuces...)

Philosophie GNU/Linux et Open Source :

www.gnu.org (site incontournable sur le mouvement GNU).

www.france.fsfeurope.org (site incontournable, la Free Software Foundation).

www.stallman.org (site incontournable, le fondateur du mouvement libre, du projet GNU : Richard Stallman (R.M.S.).

www.aful.org

www.gnu.org/licenses/gpl.html (la licence GPL).

www.gnu.org/software/hurd/hurd.html (site du noyau officiel du projet GNU, le Hurd).

Distributions et programmes :

www.linuxiso.org (les distributions GNU/Linux)

www.framasoft.net (logiciels libres win... et GNU/Linux)

www.kde.org

www.gnome.org

www.mandrakelinux.com

www.redhat.com

freshmeat.net (répertoires de projets libres)

sourceforge.net (idem)

us1.samba.org/samba/index.html (site officiel de Samba)

www.linux.org/apps/ (plein de progs, site en anglais)

www.vim.org/ (page officielle de l’éditeur Vi)

gcc.gnu.org/ (page officielle du compilateur GCC)

www.gnu.org/software/bash/bash.html (site du shell Bash)

www.acm.uiuc.edu/workshops/linux_install/lilo.html (site de lilo)

www.gnu.org/software/emacs/emacs.html (site d’emacs)

Glossaire.

Compiler :

C’est le fait de transformer un code source en binaire, directement exécutable et compréhensible par l’ordinateur. Ceci ce fait grâce à un compilateur.

Console :

C’est un shell, une fenêtre avec un prompt, dans laquelle vous tapez les commandes. Le shell (il en existe plusieurs : bash, tcsh, ksh, ash..., le plus utilisé étant le shell bash) est le programme qui se charge d’exécuter vos commandes. Sous GNU/Linux, on parle aussi de console virtuelle, au nombre de 12.

Daemons :

Ce sont des programmes chargés au démarrage.

Libre :

Un logiciel libre est distribué avec son code source, que l’on peut modifier ou redistribuer selon les termes de la licence Gnu Public Licence (GPL), ou une licence de type BSD. C’est le principe de développement de GNU/Linux et d’une grande majorité des applications livrées avec celui-ci.

Lien symbolique :

C’est un concept d’Unix. Cela permet à un fichier d’apparaître à plusieurs endroits dans l’arborescence, sans qu’il ait été copié.

Noyau ou kernel :

C’est le programme de base de GNU/Linux, qui gère l’ordinateur, les périphériques, le réseau... A la base, Linux n’est que le nom du noyau, les autres programmes venant du projet GNU (GNU is Not Unix). Mais tout le monde parle de Linux, alors que l’on devrait dire GNU/Linux.

Partition :

Lorsqu’on doit utiliser un disque dur, il faut d’abord le structurer en une ou plusieurs sous-parties, afin d’y installer un système d’exploitation.

Point de montage :

C’est le répertoire particulier (cela vient d’Unix) auquel est attaché un système de fichier, qu’il se trouve sur une disquette, un cd-rom ou un disque dur.

PID :

C’est le Process ID, le numéro d’identification alloué par le noyau à chaque processus (puisque GNU/Linux est un système multi-tâches), et qui lui permet de le suivre et de communiquer avec lui. Chaque PID est unique.

Processus :

Chaque programme exécuté par le processeur. Il existe trois types principaux de processus : les processus interactifs, les traitements pat lots, et les démons. Chaque processus possède son propre identifiant (le P.I.D).

Runlevels :

Ce sont les différents niveaux d’exécution des programmes au démarrage.

Script :

Un script est un programme écrit dans un langage interprété. Contrairement aux programmes écrits en langage compilé, les scripts sont traduits en langage machine au fur et à mesure de leur exécution.

Swap :

C’est la mémoire virtuelle de GNU/Linux, qu’il utilise lorsque la mémoire vive est pleine.

Système d’exploitation, Operating System (OS) :

C’est l’interface entre le matériel et les logiciels.

Système de fichier :

C’est la manière dont sont structurées les données sur une partition, un cd-rom, une disquette. Pour GNU/Linux, on utilise généralement le type ext3 (qui est « journalisé », c’est à dire qu’il garde sur le disque un « journal » des opérations à effectuer, pour, ensuite, les effectuer, ce qui rend ce système plus fiable.