Foire aux questions

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 :

$ fuser /bin/zsh
/bin/zsh: 1942e 2860e 2996e 3469m 3487e 4527m 4607e

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 :

$ 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

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 !) :

$ cat fichier1 > fichier_sauvegarde

Si l'on veut rajouter des données au fichier, on utilisera la double redirection '»' :

$ 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

Vous remarquerez que la dernière commande a le même effet que la première.

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 :

$ cat fichier | grep YES

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 :

$ cat fichier | ls

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).

nyal $ cat fichier | grep YES | sed 's/YES/NO/'

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

$ chmod a+t objet

• Pour l'enlever

$ chmod a-t objet

C'est aussi le 1 de la première position lorsque l'on utiliser un masque à quatre chiffres avec la notation octale de chmod

A l'aide des commandes grep et cut, on va extraire l'occurrence ”/home/francois“ du fichier /etc/passwd :

$ cat /etc/passwd | grep francois
francois:x:502:502::/home/francois:/bin/zsh

La commande grep permet de ne conserver que la ligne contenant “francois” de la sortie standard de cat.

$ cat /etc/passwd | grep francois | cut -f6 -d:
/home/francois

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).

La commande find permet de faire le plus rapidement possible ce genre de traitement. Pour afficher les fichiers vieux de plus de 24 heures :

$ find . -ctime +1

Pour les effacer :

$ 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 &
$

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 :

$ xpdf toto.pdf

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 :

$ bg

Il existe de nombreux programmes ftp en mode console. Voici un exemple pour exécuter des commandes ftp automatiquement :

$ lftp -c "open nom_de_domaine ; user login password ; mput src destination ; ls"

ou :

$ ncftp -u login -p passwd host << EOF
get fichier
ls
EOF

Ces méthodes sont utilisées dans les scripts shell (par cron notamment).

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 :

screen -dmS nom_du_screen  'commande_a_lancer' 

Vous entrez directement dans votre screen en lancant la commande. Pour détacher le screen de votre terminal:

CTRL+A CTRL+D 

Pour attacher le screen à votre terminal :

$ screen -x nom_du_screen

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.

$ toto="bonjour le monde" 
$ echo ${toto:$((${#toto}-10))} 
r le monde 

• extrait la sous chaine de $var à partir caractère n° x jusqu'à la fin:

${var:x} 

• permet de faire des calculs:

$((...))

ou l'équivalent C++ à

 for (int i=4; i<=8; i++) { ... }

for i in `seq 4 8`; do
   # commande
done 

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).

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…

Les pdf peuvent être lus par différents programmes :

• Acrobat Reader pour Linux (proche de la version windows)
• gpdf (intégré à Gnome)
• xpdf
• gv

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 :

• bchunk
• bin2iso

Exemple d'utilisation :

$ bchunk file.bin file.cue new_file
$ mount -o loop new_file.iso /mnt/cdrom

Notez que des programmes graphiques comme K3B (équivalent d'applications comme Nero sous Windows) gèrent ces formats de fichiers et permettent donc de graver très facilement.

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).

Il vous suffit de lancer la commande

$ fuser -c mon_fichier

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.

La suite Open Office (OpenOffice.org) permet de lire et d'éditer des fichiers Microsoft Office (.doc, .ppt, …). En mode console, vous pouvez utiliser antiword notamment. Si Open Office est la plus aboutie des suites bureautiques, il en existe aussi d'autres dont 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 (import) :

$ import screenshot1.png

Les archives .gz peuvent être manipulées par la commande gzip. Compresser un fichier :

$ gzip test.txt

Décompresser un fichier :

$ gzip -d test.txt.gz

ou

$ gunzip test.txt.gz

Les archives bz2 se manipulent comme les archives gz. Compresser un fichier :

$ bzip2 test.txt

Décompresser un fichier :

$ bzip2 -d test.txt.bz2

ou

$ bunzip2 test.txt.bz2

Si vous souhaitez une meilleur compression, les archives bz2 sont conseillées.

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) :

$ mkfs.vfat /dev/fd0H1440

Ensuite, montez la disquette :

$ mount -t vfat /dev/fd0H1440 /mnt/floppy

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 :

$ umount /mnt/floppy

Exécutez la commande :

$ mount -t iso9660 /dev/cdrom /mnt/cdrom

Si le lien /dev/cdrom n'existe pas, vous pouvez le créer en le faisant pointer vers votre lecteur de CD :

$ ln -s /dev/hdb /mnt/cdrom

Pour éjecter le CD, exécutez :

$ umount /dev/cdrom && eject

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

$ mkdir -p /mnt/usb

puis faites le montage :

$ mount -t vfat /dev/sda1 /mnt/usb

Pour démonter la clef, c'est comme un filesystem normal.

$ umount /mnt/usb

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.

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'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é.

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.

$ ln -s /usr/lib/j2re1.5-sun/plugin/i386/ns7/libjavaplugin_oji.so /usr/lib/mozilla-firefox/plugins/

Redémarrer le navigateur pour prendre en compte le nouveau plugin installé.

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 :

$ cat lettre.tex

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.

$ cat -v /bin/ls

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 :

$ cat lettre.txt rapport.txt conclusion.txt

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 :

$ cat lettre.txt rapport.txt conclusion.txt > publication.txt

Ainsi le fichier publication.txt aura pour contenu la concaténation des fichiers lettre.txt, rapport.txt et conclusion.txt.

La commande tac est homologue à cat mais affiche le contenu d'un fichier en partant de la dernière ligne vers la première.

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 :

$ head lettre.tex

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é.

$ head -n5 lettre.tex

Affichage des 5 premières lignes.

$ head -vc20 lettre.tex

Affichage des 20 permiers caractères après le nom du fichier.

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 :

$ tail lettre.tex

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é.

$ tail -n5 lettre.tex

Affichage des 5 dernières lignes.

tail -vc20 lettre.tex

Affichage des 20 derniers caractères après le nom du fichier.

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.

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 :

$ nl lettre.tex

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.

$ nl -ba lettre.tex

Numérote et affiche toutes les lignes du fichier. Synonyme de cat -n lettre.tex.

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 :

$ uniq lettre.tex

Affiche le contenu du fichier lettre.tex sur la sortie standard en ométant les duplications de lignes lorsqu'elles sont contigues.

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 :

$ sort -bdf essai.txt

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).

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 :

$ sort fichier1 fichier2 | uniq -d

$ 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

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 :

$ 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.

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 :

$ split -b 130000 cours_de_c.pdf.gz cours_de_c.pdf.gz.

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 :

 
$ cat cours_de_c.pdf.gz.* > cours_de_c.pdf.gz
$ gunzip cours_de_c.pdf.gz
$ acroread cours_de_c.pdf

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 :

$ diff .signature .signature.old
3a4
> .signature.old

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:

$ diff -q .signature .signature.old
Files .signature and .signature.old differ

Exemple :

$ diff -q .signature .signature
Files .signature and .signature are identical

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 :

$ wc mail.txt

Sans options, wc renvoie atomatiquement le nombre de de lignes (l), de mots (w) et de caractères ©.

Exemple :

$ wc -lL mail.txt

Renvoie le nombre de lignes (l) et la taille maximale d'une ligne (L).

Exemple :

$ wc mail.txt
12     108     671   mail.txt

Dans l'exemple précédent, le fichier mail.txt comporte 12 lignes, 108 mots et 671 caractères.

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 :

 
$ file ../*
../DATA:       directory
../cv.doc:     Microsoft Word document
../tp6.c:      program text C++
../mail.txt:   international ascii text

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.

La commande touch permet de créer un nouveau fichier vide. Syntaxe :

$ touch fichier

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.

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 :

$ locate nom_du_fichier 

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 :

$ find / -name "fichier.txt"

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 :

$ find / -name "toto*"

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 :

$ find / -type f -name "le_fichier_a_chercher" 2>/dev/null 

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 :

$ find <repertoire_depart> -type f -exec grep -H "<chaine_ou_regexp>" {} ;

Lorsqu'il s'agit de gros volumes de fichiers :

$ find <repertoire_depart> -type f | xargs grep -H "<chaine_ou_regexp>"

Renommer tous les fichiers conenant chaine en chene :

$ for i in `ls *chaine*` ; do mv $i `echo $i | sed 's/chaine/chene'` ; done

En récursif sur une arborescence :

$ for i in `find . -type f -name "*chaine*" ; do mv $i `echo $i | sed 's/chaine/chene'` ;done

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 :

$ find . -type f -name "*.conf" | xargs perl -pi.save -e 's/option\=true/option\=false/'

Pour lire les divx, il vous faut un lecteur multimedia. Il en existe une multitude dont notamment :

• MPlayer
• Xine
• Videolan

Exemple d'utilisation:

$ mplayer test.avi

Il vous faut d'abord vous assurer que /dev/dvd pointe bien sur votre lecteur dvd (les lecteurs utilisent ce lien par défaut) :

$ ln -s /dev/hda /dev/dvd

Ensuite, installez un des lecteurs suivants :

• ogle (premier lecteur à supporter les menus)
• Totem
• Xine
• Videolan
• MPlayer (pas encore de support des menus)

Lire le titre 1 du dvd :

$ mplayer dvd://1

Lecture de la piste audio anglaise, avec sous-titres français, du chapitre 1 au 4 :

$ mplayer dvd://1 -alang eng -slang fr -chapter 1-4

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.

La plupart des distributions ont des programmes pour lire les fichiers audio ou CD audio, citons-en : XMMS connu comme un équivalent de Winamp sous Windows. D'autres lecteurs multimédia le permettent également, comme Xine par exemple.

If faut utiliser les 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.

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.

Oui ! Grâce à explore2fs.

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 :

$ mount -o umask=020 -t vfat /dev/partition_windows /mnt/rep

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) :

$ nyal # mount -o umask=020 -t ntfs /dev/partition_windows /mnt/rep

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).

Pour régler l'heure, vous pouvez utiliser la commande date (date [MMDDhhmmCC]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 :

$ date 061122462004

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 Linux From Scratch ou gentoo.

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) :

ca::ctrlaltdel:/sbin/shutdown -t5 -rf now

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.

Vous pouvez pour cela utiliser df (disk free), exemple :

$ 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

En utilisant la commande apm, exemple :

$ apm
AC on-line, battery status critical: 100%

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 :

nom_utilisateur ALL=(ALL) NOPASSWD:ALL

L'utilisateur spécifié peut maintenant exécuter des commandes réservées au root en tapant :

$ sudo commande

Le paramètre “NOPASSWD” indique à sudo qu'il ne doit demander le mot de passe de l'utilisateur avant de lancer la commande.

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 :

$ mount -t ext2 /dev/hda1 /mnt

Exécutez les commandes :

$ cd /mnt
$ chroot /mnt 

Il ne vous reste plus qu'à changer le password :

$ password root

Maintenant, vous pouvez relancer linux et utiliser votre nouveau password pour le compte root.

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

$ init s

Création d'un système de fichiers sur la nouvelle partition + répertoire pour copier le contenu

$ mkfs.ext3 /dev/hdxx
 mkdir -p /mnt/new_usr

On monte la nouvelle partition et on copie les données sur la nouvelle partition

$ 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

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

$ rm -rf /usr/* 

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

$ 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

En lisant le contenu de cpuinfo : </code> $ cat /proc/cpuinfo </code> ou

$ dmesg | grep CPU

Vous avez à votre disposition des commandes telles que lspci (ou, pour plus d'infos : lspci -v), ou encore lsusb.

Il suffit de modifier les données dans /proc/sys/kernel/printk en remplaçant

7 4 1 7

par

4 4 1 7

En principe, seul l'administrateur a le droit d'éteindre ou de rebooter la machine. Rebooter :

$ shutdown -r now
$ reboot
$ init 6

Eteindre :

$ shutdown -h now
$ halt
$ poweroff
$ init 0

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 :

# 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

La principale source d'erreur est la ligne de commande

00 01 * * * touch aa

Le système ne sait pas ou se trouve touch ou aa … Mettez donc toujours les chemins entiers pour atteindre les fichiers/executables…etc

00 01 * * * /bin/touch /tmp/aa

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 :

$ ntpdate serveur.de.temps

Exemple pour la Belgique :

ntpdate ntp.belnet.be

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 :

$ killall -9 nom_du_programme

Si la commande échoue :

$ kill -9 pid_du_programme

Pour identifier le pid du programme, lancez la commande ps :

$ ps -ax | grep nom_du_programme

Le pid du programme est le premier nombre. Sinon, vous pouvez faire :

$ kill -9 `ps -ax | grep nom_du_logiciel  | awk '{ print $1}'`

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é.

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.

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 :

$ 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 

Attention ! ne supprimer pas un fichier swap en service

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 :

dd if=/dev/zero of=/my_swap bs=1024k count=128

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 :

$ mkswap /my_swap

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 :

$ swapon -p2 /my_swap

Si l'on veut automatiser le montage du swap, il faut rajouter la ligne suivante dans le fichier /etc/fstab :

/my_swap	swap		swap	defaults,pri=2	0	0

Perte du Super Block ! Pour certaines raisons, il arrive que le superblock d'un filesystem soit corrompu. Executez :

$ mkfs -n /dev/ma_partition

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

$ fsck -b mon_superblock_de_secours /dev/ma_partition

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

$ smartctl -t long /dev/hdX

Pour voir ensuite le résultat, il faut patienter quelques minutes avant de demander d'afficher le rapport :

$ smartctl -l selftest /dev/hdX

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.

Il vous suffit d'installer le logiciel john. Faites une copie du /etc/shadow dans le répertoire root et lancer john

$ cp /etc/shadow /root/
$ cd /root
john shadow

Vous pouvez arréter le traitement à tout moment via Ctrl+C et le reprendre par :

$ john -restore

Le traitement est assez long et prend du temps CPU.

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 :

$ usermod -e 2005-12-05 -f 3 mon_user

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.

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.

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.

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.

Via dd, vous pouvez sauvegarder votre mbr

$ dd if=/dev/hda of=/tmp/mon_mbr bs=512 count=1

Pour le restaurer… bah l'inverse

dd if=/tmp/mon_mbr of=/dev/hda bs=512 count=1

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.

Pour LILO, exécuter :

$ lilo -u

Indépendamment du chargeur d'amorçage, exécuter (sous dos) :

$ fdisk /mbr

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:

640x480	769
800x600	771
1024x768	773
1280x1024	775

• 16 bits:

640x480	785
800x600	788
1024x768	791
1280x1024	764

• 32 bits:

640x480	786
800x600	789
1024x768	789
1280x1024

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.

$ mount /dev/hdaX /mnt

Change le répertoire de root

$ chroot /mnt

Mances lilo pour mettre à jour le MBR.

$ lilo

Puis sorw

$ exit

Démontage pour faire propre

$ cd / ; umount /mnt

Et reboot de l'ordinateur.

Dans le fichier /boot/grub/menu.lst, faites les modifications suivantes :
Le bloc servant à démarrer Windows

title      Microsoft Windows XP Professionnel
root      (hd0,0)
savedefault
makeactive
chainloader   +1

Il suffit en effet de mettre ce bloc en tête des autres blocs. Vous obtenez :

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 

Prendre un cd live (Knoppix par exemple) et booter ton ordi dessus. Montes ta partition / de ton systeme (par exemple /dev/hdaX) dans /mnt.

$ mount /dev/hdaX /mnt

Change le répertoire de root

$ chroot /mnt

Lances grub-install sur le disque de boot, pour que Grub se réinstalle dans le MBR.

$ grub-install /dev/hda

Puis sortir:

$ exit

Démontage pour faire propre

cd / ; umount /mnt

Et reboot de l'ordinateur.

Simplement tapez :

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

Sur un réseau de classe C :

$ ping -b 192.168.0.255

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 :

$ ifconfig ethX

vous donnera l'adresse de broadcast.

Oui. Vous pouvez utiliser Lynx (présent dans la plupart des distributions), ou encore w3m.

Mettez dans un script au démarrage (par exemple : /etc/rc.local)

#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  

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 :

$ ifconfig eth0 | grep inet | cut -d":" -f2 | cut -d" " -f1

Si vous avez une interface PPP :

$ /sbin/ifconfig | grep "P-t-P" | sed "s/^[: a-z]*\([.0-9]*\).*/\1/"

Pour trouver l'adresse de la passerelle :

$ 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 }'

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

machineA mon_user

• Dans /etc/hosts, rajouter la machineA

x.x.x.x    machineA

• Dans (x)inetd, décommenter ou rajouter le service rsh et rlogin

shell  stream tcp  nowait root   /usr/sbin/tcpd       in.rshd

Configurer la machine A:

• Dans /etc/hosts, rajouter la machineB

y.y.y.y   machineB

Tester la connexion :

• Lancer une commande depuis la machine A:

$ rsh machineB "hostname"

Si le hostname de la machine B apparait, c'est bon.

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 :

$ ping www.google.com

Si le ping est bon, alors c'est le navigateur. Sinon, afficher /etc/resolv.conf

$ more /etc/resolv.conf

Vérifier que la ligne

nameserver x.x.x.x

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

$ ping 216.239.57.104

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 :

ping x.x.x.x

Si ce ping passe bien mais le ping de 216.239.57.104 alors votre problème se trouve au niveau du routeur.

• /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 :

127.0.0.1    localhost.localdomain    localhost
192.168.1.11    mamachine
192.168.1.12    monpc    lepc

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 :

order hosts,bind
multi on

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.

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 :

$ ssh-keygen -t rsa -b &gt nombre de bits de la clé &lt -N ""

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:

$ ssh-rsa &gt la clé publique&lt A@Source

Maintenant depuis la machine Source en utilisateur A, il vous suffit de faire : </code> $ ssh B@Destination </code>

Linux accepte la création d'interfaces réseaux virtuels de manière simple, il suffit de configurer une carte eth0:1. Exemple:

$ /sbin/ifconfig eth0:1 192.6.1.23 broadcast 192.6.1.255 netmask 255.255.255.0

Ceci autant de fois que l'on désire d'interfaces différentes.

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 :

$ /sbin/ifdown ppp0
$ /sbin/ifup ppp0

Pour connaître quelles sont les interfaces réseau sur votre machine, y compris les non actives :

$ /sbin/ifconfig -a

Programme C :

$ cat fichier.c
#include <stdio.h>

int main()
{
printf("Hello world !\n");
return 0;
}
$ gcc -o programme fichier.c
$ ./programme
Hello world !
$

Programme C++ :

$ cat fichier.cpp
#include <iostream.h>
 
int main()
{
cout << "Hello world !" << endl;
return 0;
}
$ g++ -o programme fichier.cpp
$ ./programme
Hello world !
$

L'option -o utilisée par gcc et g++ permet de spécifier le nom de l'exécutable.

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.

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.

Ajouter dans .bashrc la ligne.

PATH=$PATH:. 

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 .)

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é

$ chmod +x NOM_DE_VOTRE_JDK 

• 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 :

export PATH=$PATH:.:/chemin/de/votre/JDK/bin 
export CLASSPATH=.:/chemin/de/votre/JDK/lib/tools.jar 

• 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.

Un fichier pipe permet (entre autres) de faire dialoguer plusieurs processus entre eux sans pour autant générer par exemple des fichiers temporaires.

$ mknod /tmp/fichier_pipe p

ou

$ mkfifo /tmp/pipe