Une expression régulière en anglais Regular Expression ou RE sert à identifier une chaîne de caractère répondant à un certain critère (par exemple chaîne contenant des lettres minuscules uniquement). L'avantage d'une expression régulière est qu'avec une seule commande on peut réaliser un grand nombre de tâche qui seraient fastidieuses à faire avec des commandes UNIX classiques.
Les commandes ed, vi, ex, sed, awk, expr et grep utilisent les expressions régulières.
L'exemple le plus simple d'une expression régulière est une chaîne de caractères quelconque toto par exemple. Cette simple expression régulière va identifier la prochaine ligne du fichier à traiter contenant une chaîne de caractère correspondant à l'expression régulière.
Si l'on veut chercher une chaîne de caractère au sein de laquelle se trouve un caractère spécial (/, *, $, ., [, ], {, }, !, entre autres) (appelé aussi métacaractère), on peut faire en sorte que ce caractère ne soit pas interprété comme un caractère spécial mais comme un simple caractère. Pour cela vous devez le faire précéder par \ (backslash). Ainsi si votre chaîne est /dev, pour que le / ne soit pas interprété comme un caractère spécial, vous devez tapez \/dev pour l'expression régulière.
Le métacaractère. remplace dans une expression régulière un caractère unique, à l'exception du caractère retour chariot (\n). Par exemple chaine. va identifier toutes les lignes contenant la chaine chaine suivit d'un caractère quelconque unique. Si vous voulez identifier les lignes contenant la chaîne .cshrc, l'expression régulière correspondante est \.cshrc
Les métacaractères [ ] permettent de désigner des caractères compris dans un certain intervalle de valeur à une position déterminée d'une chaîne de caractères. Par exemple [Ff]raise va identifier les chaînes Fraise ou fraise, [a-z]toto va identifier une chaîne de caractère commençant par une lettre minuscule (intervalle de valeur de a à z) et suivi de la chaîne toto (atoto, btoto, ...., ztoto).
D'une manière plus générale voici comment [ ] peuvent être utilisés.
[A-D] intervalle de A à D (A, B, C, D). Par exemple, bof[A-D] donne bofA, bofB, bofC, bofD
[2-5] intervalle de 2 à 5 (2, 3, 4, 5). Par exemple, 12[2-5]2 donne 1222, 1232, 1242, 1252
[2-56] intervalle de 2 à 5 et 6 (et non pas 56) (2, 3, 4, 5, 6). Par exemple, 12[2-56]2 donne 1222, 1232, 1242, 1252, 1262
\d retourne un chiffre
\s caractère séparateur
\< position en début de mot
\> position en fin de mot
\b signifie recherche en fin ou début de mot
[a-dA-D] intervalle de a à d et A à D (a, b, c, d, A, B, C, D). Par exemple, z[a-dA-D]y donne zay, zby, zcy, zdy, zAy, zBy, zCy, zDy
[1-3-] intervalle de 1 à 3 et - (1, 2, 3, -) par exemple [1-3-]3 donne 13, 23, 33, -3
[a-cI-K1-3] intervalle de a à c, I à K et 1 à 3 (a, b, c, I, J, K, 1, 2, 3)
On peut utiliser [ ] avec un ^ pour identifier le complément de l'expression régulière. En français pour identifier l'opposé de l'expression régulière. Vous avez toujours pas compris ? Voici un exemple: [^0-9]toto identifie les lignes contenant une chaîne toto, le caractère juste avant ne doit pas être un chiffre (exemple atoto, gtoto mais pas 1toto, 5toto). Autre exemple [^a-zA-Z] n'importe quel caractère sauf une lettre minuscule ou majuscule. Attention à la place de ^, si vous tapez [1-3^], c'est équivalent aux caractères 1, 2, 3 et ^.
Le métacaractère ^ identifie un début de ligne. Par exemple l'expression régulière ^a va identifier les lignes commençant par le caractère a.
Le métacaractère $ identifie une fin de ligne. Par exemple l'expression régulière a$ va identifier les lignes se terminant par le caractère a.
L'expression régulière ^chaine$ identifie les lignes qui contiennent strictement la chaîne chaine.
L'expression régulière ^$ identifie une ligne vide.
Le métacaractère * est le caractère de répétition.
L'expression régulière a* correspond aux lignes comportant 0 ou plusieurs caractère a. Son utilisation est à proscrire, car toutes les lignes, même celles ne contenant pas le caractère a, répondent aux critères de recherche. x* est une source de problèmes, il vaut mieux éviter de l'employer.
L'expression régulière aa* correspond aux lignes comportant 1 ou plusieurs caractères a.
L'expression régulière .* correspond à n'importe quelle chaîne de caractères.
L'expression régulière [a-z][a-z]* va chercher les chaînes de caractères contenant 1 ou plusieurs lettres minuscules (de a à z).
L'expression régulière [^ ][^ ]* est équivalent à tout sauf un blanc.
Pour le traitement complexe de fichier, il est utile parfois d'identifier un certain type de chaîne pour pouvoir s'en servir dans la suite du traitement comme un sous programme. C'est le principe des sous chaînes, pour mémoriser une sous chaîne, on utilise la syntaxe \(expression régulière)\, cette sous chaîne sera identifié par un chiffre compris par 1 et 9 (suivant l'ordre de définition).
Par exemple, \([a-z][a-z]*)\ est une sous chaîne identifiant les lignes contenant une ou plusieurs lettres minuscules, pour faire appel à cette sous chaîne, on pourra utiliser \1. Voir dans le paragraphe sed pour un exemple.
sed est éditeur ligne non interactif, il lit les lignes d'un fichier une à une (ou provenant de l'entrée standard) leur applique un certain nombre de commandes d'édition et renvoie les lignes résultantes sur la sortie standard. Il ne modifie pas le fichier traité, il écrit tout sur la sortie standard.
sed est une évolution de l'éditeur ed lui même précurseur de vi, la syntaxe n'est franchement pas très conviviale, mais il permet de réaliser des commandes complexes sur des gros fichiers.
La syntaxe de sed est la suivante:
sed -e 'programme sed' fichier-a-traiter
ou
sed -f fichier-programme fichier-a-traiter
sed -i fichier-a-traiter
effectue un traitement en place (in-place) du fichier à traiter. Attention danger!!
Vous disposez de l'option -n qui supprime la sortie standard par défaut, sed va écrire uniquement les lignes concernées par le traitement (sinon il écrit tout même les lignes non traitées). L'option -e n'est pas nécessaire quand vous avez une seule fonction d'édition.
La commande sed est une commande très riche, ne vous sont présentées ici que les fonctions les plus courantes, pour plus de détails faites un man sed et/ou man ed.
La fonction de substitution s permet de changer la première ou toutes les occurrences d'une chaîne par une autre. La syntaxe est la suivante:
sed "s/toto/TOTO/" fichier
va changer la première occurrence de la chaîne toto par TOTO (la première chaîne toto rencontrée dans le texte uniquement)
sed "s/toto/TOTO/3" fichier
va changer la troisième occurrence de la chaîne toto par TOTO (la troisième chaîne toto rencontrée dans le texte uniquement)
sed "s/toto/TOTO/g" fichier
va changer toutes les occurrences de la chaîne toto par TOTO (toutes les chaînes toto rencontrées sont changées
sed "s/toto/TOTO/p" fichier
en cas de remplacement la ligne concernée est affichée sur la sortie standard (uniquement en cas de substitution)
sed "s/toto/TOTO/w" resultat" fichier
en cas de substitution la ligne en entrée est inscrite dans un fichier résultat
La fonction de substitution peut évidemment être utilisée avec une expression régulière.
sed -e "s/\([0-9]\{2\}\)-\([0-9]\{2\}\)-\([0-9]\{4\}\)/\3-\2-\1/" donnees.txt >donne2.txt remplace une date au format francais par une date au format américain 23-12-2005 -> 2005-12-23
Les accolades doivent être échapées.
La fonction de suppression d supprime les lignes comprises dans un intervalle donné. La syntaxe est la suivante:
sed "20,30d" fichier
Cette commande va supprimer les lignes 20 à 30 du fichier fichier. On peut utiliser les expressions régulières:
sed "/toto/d" fichier
sed /^$/d
pour détruire les lignes vides.
Cette commande supprime les lignes contenant la chaîne toto. Si au contraire on ne veut pas effacer les lignes contenant la chaîne toto (toutes les autres sont supprimées), on tapera:
sed '/toto/!d' fichier
Remarque : en fait les lignes du fichier d'entrée ne sont pas supprimées, elles le sont au niveau de la sortie standard.
La commande p (print) affiche la ligne sélectionnée sur la sortie standard. Elle invalide l'option -n.
La commande l (list) affiche la ligne sélectionnée sur la sortie standard avec en plus les caractères de contrôles en clair avec leur code ASCII (deux chiffres en octal).
La commande = donne le numéro de la ligne sélectionnée sur la sortie standard.
Ces trois commandes sont utiles pour le débogage, quand vous mettez au point vos programmes sed.
sed "/toto/=" fichier
Cette commande va afficher le numéro de la ligne contenant la chaîne toto.
La fonction q (quit) va interrompre l'exécution de sed, la ligne en cours de traitement est affichée sur la sortie standard (uniquement si -n n'a pas été utilisée).
La fonction r (read) lit le contenu d'un fichier et écrit le contenu sur la sortie standard.
La fonction w (write) écrit la ligne sélectionnée dans un fichier.
sed "/^toto/w resultat" fichier
Cette commande va écrire dans le fichier resultat toutes les lignes du fichier fichier commençant par la chaîne toto.
Under UNIX: convert DOS newlines (CR/LF) to Unix format
sed 's/.$//' file
# assumes that all lines end with CR/LF
sed 's/^M$// file
# in bash/tcsh, press Ctrl-V then Ctrl-M (sans relacher)
sed 's/a|b//'
remplace a ou b
sed -e 's/exp-reg1/exp1&exp2/' fichier
& est équivalent à \1 (évite les parenthèses).
sed -e 's/^[[:space:]]\{1,\}[0-9]\{1,\}.//' fich1 >fich2enlève les numéros de lignes au début d'une ligne.
sed permet aussi de faire des traitements sur deux lignes simultanément :
sed 'N;s/\n //g;P;D;'
ici, supprime le saut de ligne si la nouvelle ligne commence par un espace. Les ; permettent de séparer les commandes, N pour lire la ligne suivante, P pour retourner le résultat du traitement, D efface ce qui reste afin de ne pas afficher la ligne suivante deux fois.
tr -d '\n' < fichier_depart |sed 's/<\/[a-zA-Z0-9]\+>/&\n/g' >fichier_dest supprime le saut de ligne si la ligne ne finit pas par une balise html fermante (</p>).
Recherche d'une chaîne de caractères dans un fichier : grep -n toto fichiers (-n affiche le n° de la ligne)
grep -q
(silence : pas d'affichage)
grep ' '
recherche de blancs
grep -i
recherche indifféremment de la casse
Cut -d\" -f1 nom_fich
affiche la ligne en colonnes (ici 1) séparée par le caractère " (\ pour échappement)
cat fichier_a_traiter |tr -s A-Z a-z remplace les majuscules par des minuscules.
tr -d '\n' <test.txt supprime les retours charriot en fin de ligne
Commande de traitement des motifs
echo 'toto est bete' | awk '{print $1}'
affiche toto
gawk -F"\t" ‘{print $2}’ nom_fichtransforme les lignes de nom_fich en colonnes en découpant autour du caractère " (\t pour une tabulation) et affiche la colonne 2.
| Instructions | Commentaires |
|---|---|
|
a=t a=$a:t |
⇒ t:t |
| [xX1-9]t | xt ou Xt ou 1t, 2t ... 9t |
Bash possède de nombreuses fonctionnalités pour découper des chaînes de caractères. L'une des plus pratiques est basée sur des motifs.
La notation ## permet d'éliminer la plus longue chaîne en correspondance avec le motif :
$ Var='tonari no totoro'
$ echo ${Var##*to}
ro
ici le motif est *to, et la plus longue correspondance "tonari no toto". Cette forme est utile pour récupérer l'extension (suffixe) d'un nom de fichier :
$ F='rep/bidule.tgz'
$ echo ${F##*.}
tgz
La notation # (un seul #) est similaire mais élimine la plus courte chaîne en correspondance :
$ Var='tonari no totoro'
$ echo ${Var#*to}
nari no totoro
De façon similaire, on peut éliminer la fin d'une chaîne :
$ Var='tonari no totoro'
$ echo ${Var%no*}
tonari
Ce qui permet de supprimer l'extension d'un nom de fichier :
$ F='rep/bidule.tgz'
$ echo ${F%.*}
rep/bidule
% prend la plus courte correspondance, et %% prend la plus longue :
$ Y='archive.tar.gz'
$ echo ${Y%.*}
archive.tar
$ echo ${Y%%.*}
archive
| Instructions | Commentaires |
|---|---|
| if test $a -ne $b | La commande test va nous permettre de vérifier une condition la syntaxe est la suivante : test expression; |
| if [ $a -ne $b ] | ou bien [ expression ]; (ne pas oublier les espaces entre les crochets). |
Le shell étant souvent utilisé pour manipuler des fichiers, il offre plusieurs opérateurs permettant de vérifier diverses conditions sur ceux-ci : existence, dates, droits. D'autres opérateurs permettent de tester des valeurs, chaînes ou numériques. Le tableau ci-dessous donne un aperçu des principaux opérateurs :
| Opérateur | Description | Exemple |
|---|---|---|
| Opérateurs sur des fichiers | ||
| -e filename | vrai si filename existe | [ -e /etc/shadow ] |
| -d filename | vrai si filename est un répertoire | [ -d /tmp/trash ] |
| -f filename | vrai si filename est un fichier ordinaire | [ -f /tmp/glop ] |
| -L filename | vrai si filename est un lien symbolique | [ -L /home ] |
| -r filename | vrai si filename est lisible (r) | [ -r /boot/vmlinuz ] |
| -w filename | vrai si filename est modifiable (w) | [ -w /var/log ] |
| -x filename | vrai si filename est exécutable (x) | [ -x /sbin/halt ] |
| file1 -nt file2 | vrai si file1 plus récent que file2 | [ /tmp/foo -nt /tmp/bar ] |
| file1 -ot file2 | vrai si file1 plus ancien que file2 | [ /tmp/foo -ot /tmp/bar ] |
| Opérateurs sur les chaînes | ||
| -z chaine | vrai si la chaine est vide | [ -z "$VAR" ] |
| -n chaine | vrai si la chaine est non vide | [ -n "$VAR" ] |
| chaine1 = chaine2 | vrai si les deux chaînes sont égales | [ "$VAR" = "totoro" ] |
| chaine1 != chaine2 | vrai si les deux chaînes sont différentes | [ "$VAR" != "tonari" ] |
| Opérateurs de comparaison numérique | ||
| num1 -eq num2 | égalité | [ $nombre -eq 27 ] |
| num1 -ne num2 | inégalité | [ $nombre -ne 27 ] |
| num1 -lt num2 | inférieur ( < ) | [ $nombre -lt 27 ] |
| num1 -le num2 | inférieur ou égal ( < =) | [ $nombre -le 27 ] |
| num1 -gt num2 | supérieur ( > ) | [ $nombre -gt 27 ] |
| num1 -ge num2 | supérieur ou égal ( > =) | [ $nombre -ge 27 ] |
$0 $1 : les arguments.
$# : le nombre d'arguments (non compris le nom de la commande elle-même)
$* : tous les arguments
$$ : identifiant du processus du script
$? : code de sortie d'une commande
shift x : baisse le rang de l'argument n à $n-x. Ne modifie pas $0.
Il est souvent utile de définir des fonctions. La syntaxe est simple :
mafonction() {
echo "appel de mafonction..."
}
mafonction
ce qui donne :
appel de mafonction
. mafonction : la fonction est exécutée dans le shell courant (sinon un nouveau bash est exécuté)
Remarques :
Redirection de la sortie d'erreur vers la sortie standart : 2>&1
Effacer un répertoire vide :
rmdir nom_rep
Effacer un répertoire non vide : rm -rf nom_rep
| Commandes | Commentaires |
|---|---|
| find / -mtime -n -print | recherche dans / les fichiers modifiés dans les n dernières heures (ne pas oublier le signe – ou + pour avant ou après) |
| -mmin -n | dans les n dernières minutes |
| -exec commande \; ou-exec commande {} \; |
\; fin de la commande dans exec {} find substitue le chemin complet du fichier en cours. |
| find -name "*" -exec grep tata {} \; -print |
Recherche tata dans tous les fichiers -type d (f) recherche les répertoires (fichiers)seulement. |
| find /etc -exec grep '[0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*' {} \; | Trouve toutes les adresses IP (xxx.xxx.xxx.xxx) contenues dans les fichiers situés dans le répertoire /etc . |
| find / -mmin -n -exec ls {} \; |
Pour éxecuter la commande ls -l pour chaque fichier trouvé
|
| find . | liste tous les fichiers y compris dans les sous répertoires |
| find / ''.*.txt'' | Pour trouver un fichier qui commence par un point : (sinon pas d'affichage) |
| find / -name "*[~]" -exec rm -f {}\; | Efface les fichiers de sauvegarde finissant par ~ |
| find /tmp -regex .*chvar.* | Recherche selon une expression régulière (dans le chemin complet du fichier, ce qui explique les *) |
Cette commande sert à trier les lignes d’un fichier texte.
cat fichier.txt | tr 'A-Z' 'a-z' | grep '^[a-z]' | sort -u
iconv -f ISO-8859-1 -t UTF-8 index.php >index.php2
convertit un fichier
Pour voir le codage d'une machine, on peut par exemple lancer la commande echo -n é |wc -c. En utf-8 é est codé sur 2 octets (1 en ISO-8859-1).
alias toto='nom_commande -opt1 -opt2' à placer dans le fichier .bashrc
Remarque : pour relancer le chargement du profil de l'utilisateur, exécuter la commande source .bashrc
chmod u+x fich1 : ainsi le propriétaire du fichier a le droit d'exécuter linux-test (ce qui de toute manière dans ce cas ci ne servira pas à grand chose puisque fich1 n'est ni un binaire ni un script ...)
Si nous souhaitons définir d'un seul mouvement toutes les permissions d'un fichier, on peut utiliser la syntaxe suivante (nous voulons que linux-test soit en lecture, en écriture et en exécution pour le propriétaire, que le groupe n'ait le droit que de le lire et d'écrire et que les autres utilisateurs ne puissent que le lire) :
chmod u=rwx,g=rw,o=r fich1
En une seule ligne grâce au signe "=" nous avons définit l'ensemble des droits. Il existe une autre facon d'indiquer les permissions, nous aurions pu utiliser la syntaxe suivante pour l'exemple précédent :
chmod 764 fich1
La syntaxe est vraiment très différente ...
En réalité, nous venons d'utiliser la notation binaire pour définir les droits :
Petit rappel :
Binaire ------- Logique ------ Décimal
000 -------- (---) ------- 0
001 -------- (--x) ------- 1
010 -------- (-w-) ------- 2
011 -------- (-wx) ------- 3
100 -------- (r--) ------- 4
101 -------- (r-x) ------- 5
110 -------- (rw-) ------- 6
111 -------- (rwx) ------- 7
Le 0 indique donc un tiret et le 1 indique que la lettre correspondant à la position doit être inscrite. Donc pour notre exemple, rwx (pour le propriétaire) correspond à 7, rw (pour le groupe correspond à 6, et r (pour les autres utilisateurs) correspond à 4. Nous avons bien la séquence 764. les chiffres doivent être dans l'ordre, le premier pour le propriétaire, le deuxième pour le groupe, le troisième pour les autres utilisateurs.
chown : changement de propriétaire d'un fichier.
chown nom_user: tmp/ (: permet de changer le nom de groupe en même temps)
Une simple instruction 'read' peut initialiser plusieurs variables.
echo -n "Entrez les valeurs des variables 'var2' et 'var3' (séparées par des espaces ou des tabulations): "
read var2 var3
echo "var2 = $var2 var3 = $var3"
Si vous entrez seulement une valeur, le(s) autre(s) variable(s) resteront non initialisées (null).
Un read sans variable associée utilise en entrée la valeur de la variable dédiée $REPLY
let a=a+1 est équivalent à a=$[a+1] ou let ''a+=1''
set nom_commande initialise les variables de position $1 ... aux différents champs sortis par la commande nom_commande.
Exemple :
set `uname -a `
echo $2
portableibm
donne le chemin d'une commande
Même chose de which avec en plus le chemin de la page de man de la commande.
Comme "more" sauf qu'avec cette commande, on peut revenir en arrière dans le défilement du fichier.
diff - -side-by-side fichier1 fichier2 : compare deux fichiers.
Voir aussi vimdiff fichier.php{,.old} qui permet de comparer fichier.php et fichier.php.old
wc -l < toto : compte le nombre de lignes dans toto (aussi nombre de caractères et mots)
Calculatrice du shell
echo 1000/3 | bc
333
wget est un programme non-interactif de téléchargement de fichiers depuis le Web.
wget -r -p -l 1 http...
l'option -l sert à définir la profondeur de copie pour les liens html
Cette commande crée un fichier temporaire.
mktemp -p /tmp file.XXXXXX
Créer un fichier vide ou changer ses attributs :
touch nom_fich
tee fichier
écrit directement dans le fichier ce que l'on tape au clavier. Peut être utile dans les scripts.
Les programmes sont la plupart du temps fournis compressés, c'est-à-dire sous un format plus compact permettant de réduire la taille du programme, notamment pour faciliter son téléchargement, c'est le programme GZIP qui permet ce compactage. Plusieurs fichiers peuvent aussi être simplement regroupés en une seule archive pour faciliter leur transport, c'est le rôle du programme TAR. Enfin, les fichiers peuvent être compressés et regroupés en une archive portant l'extension .tar.gz.
Les données compressées existent sous plusieurs formats:
zip/unzip: les données sous ce format portent l'extension .zip
Pour décompresser ce type de données il faut taper en ligne de commande:
unzip archive.zip
Compression de plusieurs fichiers : zip archive.zip fichier1 fichier2 fichier3
Compression de plusieurs répertoires :zip -r archive.zip rep1 rep2
Tar: les données sous ce format portent l'extension .tar
pour décompresser ce type de données il faut taper en ligne de commande:
tar xvf nom_du_fichier.tar
Gzip: les fichiers compressées en Gzip possèdent l'extension .gz
pour décompresser ces fichiers il faut taper en ligne de commande:
gunzip nom_du_fichier.gz
Bzip2: les fichiers
compressées en Bzip2 possèdent l'extension .bz2
pour décompresser ces fichiers il faut taper en ligne de
commande:
bzip2 -d nom_du_fichier.bz2
Tar/GZip (on parle
généralement de Tarball): les données
compressées en TAR et en GZIP portent l'extension .tar.gz
Elles peuvent être décompressées
successivement par les deux moyens énoncés
ci-dessus ou à l'aide de la commande:
tar zxvf nom_du_fichier.tar.gz
Tar/BZip2: les données
compressées en Tar et en Bz2 portent l'extension .tar.bz2
Elles peuvent être décompressées
successivement par les deux moyens énoncés
ci-dessus ou à l'aide de la commande:
tar jxvf nom_du_fichier.tar.bz2
rar:
rar -v archive.rar
Compress: les fichiers archivés par le programme Compress portent l'extension .Z, ils peuvent être décompressés par le programme Uncompress.
Lorsque le programme est une archive (et non un RPM) il est généralement nécessaire de compiler les sources.
Bien que la compilation se fasse pratiquement toujours de la même façon pour la majorité des applications, il est vivement conseillé de lire le fichier INSTALL ou README pour connaître exactement les commandes nécessaires à la compilation du programme.
Dans un premier temps il faut exécuter la commande:
./configure
Cette commande est un script permettant d'adapter le programme à la machine courante. Les options de configure sont:
Pour obtenir de l'aide:
./configure --help
Pour installer l'application dans un répertoire spécifique:
./configure --prefix="repertoire"
Dans un second temps il faut compiler le programme, grâce à la directive
make
Cette commande peut prendre plusieurs minutes/heures selon votre configuration et le logiciel à compiler. En cas de probleme, la compilation s'arretera en vous renvoyant un message d'erreur. Si tout se passe normalement de nombreuses lignes vont être affichées, puis le programme reviendra à la ligne de commande.
Après avoir compilé l'application, il est possible de l'installer
L'installation de l'application doit s'effectuer en tant que superutilisateur (root)
Pour installer l'application, la syntaxe suivante est généralement utilisée:
make install
En cas d'échec lors de la compilation, il faut nettoyer les fichiers makefile ayant été créés automatiquement lors de la compilation avant de recommencer une nouvelle compilation. Cela se fait grâce à la commande:
make clean
Une fois toutes ces étapes franchies, votre programme devrait être exécutable et se trouver soit dans le répertoire spécifié lors de l'installation, ou bien généralement dans /usr/local/nom_du_programme.
Lancement automatique de scripts ou services (daemon)
| Niveau | Etat |
|---|---|
| 0 | arrêt de la machine |
| 1 | mode simple utilisateur |
| 2 | |
| 3 | |
| 4 | |
| 5 | Mode utilisateur habituel |
| 6 | Redémarre la machine |
Vérifier avec le niveau avec la commande /sbin/runlevel
Il est défini dans le fichier /etc/inittab
-Au démarrage
Les services sont lancés par des scripts situés dans /etc/init.d (ou dans /etc/rc.d/init.d, (qui sont souvent le même fichier, l'un étant un lien vers l'autre).Le répertoire /etc/rc.d/ contient aussi des répertoires nommés rcX.d (avec X numéro de runlevel). Chacun de ces répertoires contient un lien vers les scripts situés dans init.d.
La 1ère lettre détermine si le daemon est activé (S comme start) dans ce niveau d'exécution (runlevel) ou arrêté (K comme kill).
Les 2 chiffres permettent de trier l'ordre d'exécution des services.
Plutôt que de modifier directement les liens, on va utiliser la commande suivante :
/etc/init.d/nom_service {start|stop|restart|reload|status} ou service nom_service {start|stop|restart|reload|status}
Ajouter ces propres services : voir chkconfig et chkconfig --list
Un démon crond : c'est lui qui se charge d'exécuter les travaux progammées à l'aide de cron. Toutes les minutes ils vérifie la présence de nouveaux fichiers de configuration (crontab). Là encore, comme les autres services, il est situé dans /etc/init.d. Le démon doit être actif pour que les tâches puissent être exécutées.
Un fichier de configuration, la crontab : il contient les travaux programmés et la date d'exécution. Il y a une crontab par utilisateur ayant recours à cron. Ces fichiers sont situés (habituellement) dans /var/spool/cron. Ils ne sont pas conçus pour être édités directement.
crontab -e : permet d'éditer la crontab et éventuellement de la modifier. La commande ouvre la crontab dans un éditeur vi.
1ère colonne, les minutes : de 0 à 59
2ème colonne, les heures : de 0 à 23
3ème colonne, le jour du mois : de 0 à 31
4ème colonne, les mois : de 0 à 12
5ème colonne, le jour de la semaine : de 0 à 7 (de dimanche à samedi)
6ème colonne, la tâche à exécuter
* : toutes les valeurs de la plage de temps
Comme vous pouvez le voir dans le fichier /etc/crontab, le script run-parts est utilisé pour l'exécution des scripts dans les fichiers /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly et /etc/cron.monthly (toutes les heures, tous les jours, toutes les semaines ou tous les mois, respectivement).
/sbin/service anacron status pour voir si le service est lancé
vi /etc/anacrontab
export permet de définir une variable du shell
Exemple : export a="bonjour"
echo $a retourne bonjour
Autre exemple : changer le prompt export PS1='\u@\h\W'
Le prompt peut être paramétré dans le fichier /etc/bashrc. Pour relancer le chargement du profil, exécuter : . .bashrc dans /home/philippe ou . /etc/bashrc (le point execute le contenu du fichier dans le shell courant).
| \$ | Pour afficher une terminaison personnalisée. Par défaut on a $ pour les utilisateurs et # pour le root. |
| \d | Pour ajouter la date (au format anglais). |
| \h | Pour ajouter le nom de la machine. |
| \r | Pour un retour à la ligne. |
| \t | Pour ajouter l'heure (HH:MM:SS). |
| \u | Pour ajouter le nom de l'utilisateur. |
| \w | Pour ajouter le chemin complet du répertoire courant. |
| \W | Pour ajouter le répertoire courant. |
La liste des variables d'environnement est donnée par la commande env.
Remarque : gvim=gnome-vi est l'interface graphique de vi sous gnome
Vi et Vim utilisent le fichier .viminfo dans /home/philippe
Voici quelques commandes utiles sous vi :
vi fichier +n : permet d'aller à la ligne n
vi *.php : permet d'ouvir tous les fichiers php. Pour aller au suivant :n. Pour aller au précédent :N.
:redo ou ctr+R annuler retour en arrière u
:1,$s/^/toto/ insère toto en début de chaque ligne
:1,$s/^[[:blank:]]\+$// efface les blancs dans les lignes vides
:g/^$/d efface toute les lignes vides
:set list : afficher les tabulations
Pour changer l'encodage d'un fichier : set fileencoding=iso-8859-1 ou utf-8
Pour passer un fichier dos (crlf) au format unix, il suffit de taper :set fileformat=unix, puis de sauvegarder. (aussi en ligne de commande avec dos2unix)
ctrl-p pour complémenter le nom d’une variable
gg=G pour réindenter tout un document
:set tabstop=4 pour spécifier la tabulation
:syn on pour avoir les couleurs
:filetype on pour utiliser le mode d’édition lié au type de fichier (défini selon l’extension de celui-ci)
:set ts=2 sw=2 permet de régler, notamment pour le php, la taille de la tabulation
:r fich1 : insère le contenu de fichier au delà du curseur
v permet de sélectionner une zone ; on peut ensuite utiliser d pour l’effacer et p (paste) pour coller la sélection ailleurs.
Sinon, n’oubliez pas la commande magique (en ligne de commande, pas dans vi) : vimtutor
Modifier la taille d'images (largeur=800) "$i" évite des pb en cas de blancs dans les noms de fichiers
j=0;for i in *.*; do convert -resize 800 "$i" sauv/img-$j.jpg; j=$[j+1];echo $j; done;
Programme de visualisation d'images
evince file.ps
dmesg : revoir les messages de la séquence de boot
sha1sum nom_fichier renvoie une clé à comparer avec celle donnée pour le download (pour le cryptage sha1)
Il existe aussi le cryptage md5. On trouve alors la signature avec la commande md5sum
fdisk -l ou -s pour voir les partitions
fdisk /dev/hda pour partionner le disque dur.
| Commandes | Description |
|---|---|
| d | destruction d'une partition |
| l | liste des types de partitions |
| m | Impression du menu en cours |
| n | Création d'une nouvelle partition (+sizeM où size prend une valeur numérique) ex : +8000M |
| p | Affichage des partitions |
| q | Sortie de fdisk sans sauvegarde des paramètres |
| t | Modification du type de partition (puis L pour avoir la liste complète) |
| v | Vérification de la table des partitions |
| w | Sauvegarde des modifications et sortie de fdisk |
Partitionnement du disque à l'aide de fdisk pour créer 3 volumes.
Procédure à suivre :
Remarque : rajouter un # dans grub.conf sur la ligne hiddenmenu
Pour connaître le partitionnement d'un disque dur linux : du -h ou du -hs/
Installation initiale de fedora 7 :
--------------------- Disk Space Begin ------------------------
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup00-rootvol
9.5G 3.6G 5.5G 40% /
/dev/sda1 29G 8.3G 20G 31% /data
/dev/sda3 76M 19M 54M 26% /boot
/dev/mapper/VolGroup00-tmpvol
496M 19M 452M 4% /tmp
/dev/mapper/VolGroup00-homevol
12G 543M 11G 5% /home
---------------------- Disk Space End -------------------------
Modifier le fichier fstab pour monter la partition /disque_d
Créer le point de montage mkdir /disque_d
Rajouter dans fstab :
/dev/sda2 /disque_d vfat user,exec,uid=500,gid=500 0 0
Monter avec mount -a
Pour voir l'uid et le gid cat /etc/passwd
En root, lancer la commande visudo et rendre active la ligne contenant %wheel ALL=(ALL) NOPASSWD: ALL
Dans le gestionnaire des utilisateurs, donner l'appartenance à wheel pour l'utilisateur concerné.
Changer le nom d'hôte: hostname
Modifier les fichiers /etc/hosts et /etc/sysconfig/network
ssh est une commande permettant de se connecter sur une machine distante (option -X pour exporter l'affichage d'une application comme nautilus).
ssh mon_login@ma_machine:/.../mon_repertoire
scp est une commande de copie de fichiers sur une machine distante.
scp mon_fichier mon_login@ma_machine:/home/.../mon_repertoire
ou
scp mon_login@ma_machine:/home/.../mon_repertoire/mon_fichier /.../mon_repertoire_local
L'option -r permet de copier un répertoire. Il est possible d'utiliser un chemin relatif sur la machine distante. L'option -p permet de conserver les dates de fichiers
scp mon_login@ma_machine:mon_repertoire/mon_fichier /.../mon_repertoire_local
sftp est une commande de copie de fichiers sur une machine distante, fonctionnant comme ftp mais passant par un tunnel cripté fourni par ssh.
Les clés sont stockées dans le fichier .ssh/known_hosts