GNU Squad » Système

Créer une image ISO Debian avec les firmwares non libres

Sylvain — Fri, 06 Nov 2009 19:53:01 +0000

Les images ISO officielles de Debian, conformément aux DFSG, ne contiennent pas de firmwares non libres ce qui peut poser problème lorsque l’on a, par exemple, des serveurs équipés de carte réseaux Broadcom NetXtreme II utilisant le module « bnx2 » qui nécessite un firmware évidemment non libre. Dans ce genre de cas, l’installateur Debian demande de fournir ce dernier via une clé USB, c’est bien mais je souhaitais sauter cette étape, c’est pourquoi j’ai développé un petit script s’occupant d’intégrer directement dans l’image ISO les firmwares non libres disponibles dans la section « non-free ». Voici le script pour les intéressés :

#!/bin/bash

#//////////////////////////////////////#
# Affiche l'aide du script             #
#                                      #
# @stdout Aide d'utilisation du script #
#//////////////////////////////////////#
usage(){
 echo "Usage : $0  (i386, amd64)"
}

#/////////////////////////////////////////////////////////////#
# Teste si l'utilisateur est loggué en root ou non            #
#                                                             #
# @return Renvoie 0 si l'utilisateur est root sinon renvoie 1 #
#/////////////////////////////////////////////////////////////#
is_root(){
 if [[ $(id -u) -eq 0 ]]; then
 return 0 ;
 else
 return 1 ;
 fi
}

#///////////////////////////////////////////////////////////#
# Vérifie la présence des programmes utilisés par le script #
#                                                           #
# @return Renvoie 0 si tous les programmes sont présents    #
#///////////////////////////////////////////////////////////#
check_installed_software(){
    if [[ -z $(which ar) || -z $(which genisoimage) || -z $(which wget) || -z $(which tar) || -z $(which zcat) || -z $(which cpio) ]]; then
        return 1 ;
    else
        return 0 ;
    fi
}

#////////////////////////////////////////////////////////////////////////#
# Télécharge l'image ISO en version netinstall de l'architecture désirée #
#                                                                        #
# @param in $1 Architecture de l'ISO à télécharger                       #
# @stdout Nom du fichier de l'image ISO téléchargée                      #
#////////////////////////////////////////////////////////////////////////#
download_iso_netinstall(){
 local ISO=$(wget -q -O- http://cdimage.debian.org/debian-cd/current/$1/iso-cd/|sed -nr 's/.*(debian.+?netinst.iso).*/\1/p')
 [[ -z $ISO ]] && {
 exit 1
 }
 wget "http://cdimage.debian.org/debian-cd/current/$1/iso-cd/$ISO" -O $ISO
 echo $ISO
}

#////////////////////////////////////////////////////////////////////#
# Extrait les fichiers d'une image ISO dans un répertoire temporaire #
#                                                                    #
# @param in $1 chemin de l'image ISO                                 #
# @stdout Chemin où se trouvent les fichiers extraits                #
#////////////////////////////////////////////////////////////////////#
function extract_files_from_iso(){
 local MOUNT_DIR=$(mktemp -d)
 local ISO_DIR=$(mktemp -du)
 mount -o loop $1 $MOUNT_DIR
 cp -a $MOUNT_DIR $ISO_DIR
 umount $MOUNT_DIR
 rmdir $MOUNT_DIR
 echo $ISO_DIR
}

#/////////////////////////////////////////////////////////////////////////////////////////////#
# Affiche le nom des paquets contenant les derniers firmwares non libres présents dans Debian #
#                                                                                             #
# @stdout Liste des paquets contenant les derniers firmwares non libres                       #
#/////////////////////////////////////////////////////////////////////////////////////////////#
list_firmware(){
 local FIRMWARE_DEB=$(wget -q -O- 'http://ftp.debian.org/debian/pool/non-free/f/firmware-nonfree/?C=N;O=D;V=1;F=0' | sed -nr "s/^ /dev/null
 rm $1 data.tar.gz
 shift
 done

 cd $OLDPWD
 echo $FIRMWARE_DIR
}

#///////////////////////////////////////////////////#
# Intègre les firmwares dans les initrd trouvés     #
#                                                   #
# @param $1 Répertoire où se trouvent le(s) initrd  #
# @param $2 Répertoire où se trouvent les firmwares #
#///////////////////////////////////////////////////#
merge_firmware_initrd(){
 local INITRD
 for INITRD in $(find $1 -name initrd.gz); do
 local TMP_DIR=$(mktemp -d)
 cd $TMP_DIR
 zcat $INITRD | cpio -i &> /dev/null
 cp -a $2/lib/firmware .
 find . -print0 | cpio -0 -H newc -o 2> /dev/null | gzip -c > $INITRD
 cd $OLDPWD
 rm -rf $TMP_DIR
 done
}

#////////////////////////////////////////////////////////////////////////////#
# Mise à jour des sommes MD5                                                 #
#                                                                            #
# @param $1 Répertoire où se trouve le fichier de sommes MD5 à mettre à jour #
#////////////////////////////////////////////////////////////////////////////#
update_md5sum(){
 cd $1
 find . -type f ! -name md5sum.txt -exec md5sum {} \; > md5sum.txt
 cd $OLDPWD
}

#/////////////////////////////////////////////////////////////////////////#
# Génère une image ISO à partir d'un répertoire                           #
#                                                                         #
# @param $1 Répertoire contenant les fichiers à intégrer dans l'image ISO #
# @param $2 Chemin vers le fichier à générer                              #
#/////////////////////////////////////////////////////////////////////////#
build_iso_image(){
 genisoimage -no-emul-boot -r -J -boot-load-size 4 -boot-info-table -b isolinux/isolinux.bin -c isolinux/boot.cat -o $2 $1 &> /dev/null
}

#///////////////////////#
# Vérifications de base #
#///////////////////////#
check_installed_software
[[ $? -eq 1 ]] && {
    echo "Certains programmes nécessaires au fonctionnement du script n'ont pas été trouvés." >&2
    exit 1
}

[[ $# < 1 ]] && usage && exit 1
ARCH=$1

! is_root && {
 echo 'Ce script a besoin des droits root !' >&2
 exit 1
}

#///////////////////////////////#
# Téléchargement de l'image ISO #
#///////////////////////////////#
echo "Téléchargement de l'image ISO"
ISO=$(download_iso_netinstall $ARCH)
[[ $? -eq 1 ]] && {
 echo "Erreur : l'image ISO netinstall de l'architecture « $ARCH » n'a pas été trouvée." >&2
 exit 1
}

#/////////////////////#
# On crée l'image ISO #
#/////////////////////#
echo "Extraction des fichiers de l'image ISO"
ISO_DIR=$(extract_files_from_iso $ISO)
echo "Téléchargement des firmwares"
FIRMWARE_DIR=$(download_and_extract_firmware $(list_firmware))
echo "Intégration des firmwares"
merge_firmware_initrd $ISO_DIR $FIRMWARE_DIR
echo "Création de l'image ISO finale"
update_md5sum $ISO_DIR
NEW_ISO=${ISO/./.homemade.}
build_iso_image $ISO_DIR $NEW_ISO
echo "Image ISO originale : $ISO"
echo " Nouvelle image ISO : $NEW_ISO"

#////////////////////////////////////////#
# On nettoie les répertoires temporaires #
#////////////////////////////////////////#
rm -rf $FIRMWARE_DIR $ISO_DIR

Liens :

Variables variables en Bash

Sylvain — Wed, 21 Oct 2009 19:29:00 +0000

Il peut parfois être pratique d’avoir des noms de variables qui soient variables. C’est-à-dire un nom de variable qui est affecté et utilisé dynamiquement. En bash, il suffit de d’utiliser la construction « ${!variable} » pour déréférencer la variable ayant son nom contenu dans $variable. Voici un exemple d’utilisation concret :

#!/bin/bash

BACKUP_DAY=10
BACKUP_WEEK=4

LIST=( DAY WEEK )
for i in ${LIST[@]}; do
    i="BACKUP_$i"
    echo "$i : ${!i}"
done

Affichera :

BACKUP_DAY : 10
BACKUP_WEEK : 4

À lire :

Man bash

Équivalents de dirname & basename en Bash

Sylvain — Wed, 21 Oct 2009 16:16:28 +0000

Les programmes dirname et basename sont très pratiques lors de l’écriture de scripts bash mais impliquent une exécution externe ce que les puristes aiment bien éviter. Voici, pour les intéressés, leurs équivalents en bash accompagnés d’une batterie de tests pour valider leur fonctionnement par rapport aux programmes de base :

#!/bin/bash

function basename(){
    echo ${1##*/}
}

function dirname(){
    local file=$1
    case $file in
        /*) ;;
        ./*) ;;
        *) file=./$file ;;
    esac
    file=${file%/*}
    echo ${file:-/}
}

PROGS=( dirname basename )
LIST_FILES=( /test.txt /tmp/test.txt /tmp/plop/test.txt ./test.txt ./tmp/test.txt ./tmp/plop/test.txt test.txt )

for prog in ${PROGS[@]}; do
    echo "--> $prog <--"
    for file in ${LIST_FILES[@]}; do
        SYSTEM=$(bash -c "$prog $file")
        MINE=$($prog $file)
        [[ $SYSTEM != $MINE ]] && echo -e "$file\nSystème : $SYSTEM\nLe mien : $MINE"
    done
done

Une petite comparaison rapide entre les deux solutions montre des performances supérieures de 75% en faveur de la solution bash. En pratique, la différence sera bien évidemment insignifiante sauf si vous vous amusez à itérer un grand nombre de fois sur ces fonctions.

Note : les options –help, –version ainsi que le paramètre permettant d’indiquer un suffixe pour basename ne sont pas pris en compte.

À lire :

Visualisez la hiérarchie de vos inclusions PHP avec « Inclued »

Sylvain — Fri, 06 Mar 2009 19:58:14 +0000

L’extension PECL « Inclued » permet de tracer et d’enregistrer sous forme hiérarchique, l’ensemble des inclusions de fichiers durant l’exécution d’un script PHP.

Prenons pour exemple le monstrueux WordPress, voici ce que l’on peut obtenir :

Mis à part le fait que ce genre de graphe est toujours sympa à voir, il permet de se faire une idée sur la qualité d’un code :

Pourquoi ce fichier est inclut alors qu’il n’est pas utilisé ?
Pourquoi ce fichier est inclut ici plutôt que là ?
Pourquoi ce fichier n’est pas inclus en utilisant les primitives *_once ?
Pourquoi les inclusions proviennent uniquement de ce fichier ?
etc.

Passons au vif du sujet ! Pour commencer nous allons installer les paquets nécessaires pour la suite des opérations :

php5-dev et make pour la compilation de l’extension
php5-cli et graphviz pour la génération des images

root@gnusquad:~# aptitude install php5-dev php5-cli make graphviz

Une fois ces paquets installés, téléchargeons l’extension « Inclued » et décompressons la d’un trait :

root@gnusquad:~# wget -q -O - http://pecl.php.net/get/inclued | tar zx

Compilons cette dernière :

root@gnusquad:~# cd inclued-0.1.0
root@gnusquad:~/inclued-0.1.0# phpize
root@gnusquad:~/inclued-0.1.0# ./configure
root@gnusquad:~/inclued-0.1.0# make

L’étape qui suit consiste à indiquer à PHP de charger cette nouvelle extension :

root@gnusquad:~/inclued-0.1.0# cp modules/inclued.so /usr/lib/php5/20060613+lfs
root@gnusquad:~/inclued-0.1.0# vi /etc/php5/conf.d/inclued.ini

extension=inclued.so
inclued.enabled=on
inclued.dumpdir=/tmp

On peut dès lors redémarrer le serveur web, Apache en l’occurence, sachant que désormais, chaque accès à un fichier PHP (via le web ou en CLI) générera un fichier dans le répertoire /tmp donc méfiance !

root@gnusquad:~/inclued-0.1.0# /etc/init.d/apache2 restart

Sachez qu’il est également possible d’activer l’extension au niveau du serveur web en utilisant les directives php_admin_flag et php_admin_value ce qui permet de limiter l’extension à un vhost par exemple. Malheureusement, et contrairement à ce qui est indiqué sur le site PHP, il n’est pas possible d’utiliser ces directives dans un fichier .htaccess.

Les fichiers générés n’étant pas directement des images, il faut les convertir à l’aide d’un script fourni avec l’extension que nous enroberons de notre propre script afin de nous faciliter la vie :

root@gnusquad:~/inclued-0.1.0# cp gengraph.php /usr/local/bin
root@gnusquad:~/inclued-0.1.0# cd $_
root@gnusquad:/usr/local/bin# vi gengraph

#!/bin/bash
echo "Generating file $1.png"
exec >/dev/null
php -d "inclued.enabled=Off" $(dirname $0)/gengraph.php -i $1 -o $1.dot
dot -Tpng -o $1.png $1.dot
rm $1
rm $1.dot

root@gnusquad:/usr/local/bin# chmod +x $_

Voilà, le plus dur est fait, il ne vous reste plus qu’à aller sur une page web PHP et à générer l’image :

root@gnusquad:/usr/local/bin# cd /tmp
root@gnusquad:/tmp# ls
inclued.00688.1
root@gnusquad:/tmp# gengraph inclued.00688.1
root@gnusquad:/tmp# ls
inclued.00688.1.png

À lire :

Mise à jour du 05 mai 2009 : pour effectuer la compilation encore plus simplement, il suffit de taper « pecl install channel://pecl.php.net/inclued-0.1.0 » et le tour est joué !

Problème d’accès à l’IP publique d’une Freebox à travers le NAT

Sylvain — Mon, 23 Feb 2009 06:20:24 +0000

Voici un état des lieux : je dispose d’une Freebox v4, j’ai activé le NAT et le DHCP (adresses IP fixées par adresse MAC) pour mes PC. Il y en a un qui est entièrement accessible depuis internet grâce à l’option « IP DMZ » présente dans la console d’administration de la Freebox qui redirige toutes les connexions entrantes non encore établies en provenance d’internet vers l’adresse IP désignée, dans mon cas 192.168.0.1. Mon adresse IP publique est associée au domaine gnusquad.org donc tout le traffic à destination de ce domaine part sur le PC ayant l’IP 192.168.0.1.

Voici un schéma afin d’être plus clair :

Le problème est qu’il est impossible depuis le PC ayant l’IP 192.168.0.2 d’accéder, par exemple, à mon blog (http://blog.gnusquad.org), la résolution DNS renvoyant mon adresse IP publique et la Freebox ne redirigeant le traffic « IP DMZ » que depuis le WAN et non le LAN !

Ma solution initiale était d’ajouter sur le PC ayant l’IP 192.168.0.2, une entrée dans le fichier « /etc/hosts » qui pour rappel, permet de fixer une adresse IP pour une liste de domaines et de sous-domaines :

root@gnusquad:~# vi /etc/hosts

192.168.0.1 gnusquad.org www.gnusquad.org blog.gnusquad.org man.gnusquad.org
...

Cette solution a le mérite d’être simple et rapide à mettre en œuvre mais a comme désavantage le fait de devoir tenir à jour cette entrée par rapport à la liste grandissante des sous-domaines hébergés sur la même machine.

Il était donc temps de trouver une solution plus confortable, c’est pourquoi j’ai décidé d’installer un proxy DNS, en l’occurence pdnsd qui me permettrait de modifier les enregistrements DNS à ma guise.

root@gnusquad:~# aptitude install pdnsd

L’installation vous demandera si vous préférez utiliser les DNS fournis par le programme resolvconf, les DNS des serveurs racines ou bien encore si vous préférez les indiquer manuellement.
Utilisant resolvconf, ce que je vous conseille au passage, j’ai choisi cette option ce qui aura pour conséquence, au lancement de pdnsd de mettre l’IP 127.0.0.1 dans le fichier /etc/resolv.conf à la place des DNS de votre FAI, ces derniers étant utilisés par le proxy pour la résolution de noms.

Il faut ensuite, désactiver la génération automatique du fichier de configuration du proxy en commentant la ligne AUTO_MODE du fichier /etc/default/pdnsd.conf . Vous pouvez également spécifiez des options de démarrage via la variable START_OPTIONS ce qui peut être utile pour activer le mode debug (option –debug). Voici ce que ça donne une fois le fichier modifié :

root@gnusquad:~# cat /etc/default/pdnsd.conf

# do we start pdnsd ?
START_DAEMON=yes
# auto-mode, overrides /etc/pdsnd.conf if set [see /usr/share/pdnsd/]
#AUTO_MODE=resolvconf
# optional CLI options to pass to pdnsd(8)
START_OPTIONS="--debug"

Maintenant il ne reste plus qu’à configurer le proxy DNS pour renvoyer l’IP 192.168.0.2 pour toutes demandes de résolution de noms portant sur le domaine gnusquad.org ce qui se fait aisément une fois après avoir lu la man page du fichier pdnsd.conf :

root@gnusquad:~# vi /etc/pdnsd.conf

...
rr {
    name=gnusquad.org;
    ns=localhost;
    reverse=on;
    a=192.168.0.1;
}
rr {
    name=*.gnusquad.org;
    a=192.168.0.1;
}
...

Il ne reste plus qu’à redémarrer le proxy DNS pour que les changements soient pris en compte :

root@gnusquad:~# /etc/init.d/pdnsd restart
Stopping pdnsd.
Starting pdnsd.

Pour terminer, sachez que pdnsd fait également office de cache DNS pour accélérer les résolutions de noms, ce cache se trouve dans le fichier /var/cache/pdnsd/pdnsd.cache que vous pouvez supprimer sans souci si vous rencontrez quelques problèmes durant vos tests. Quant aux logs, ceux-ci se trouvent dans le fichier /var/cache/pdnsd/pdnsd.debug.

À lire :

Mettre en surbrillance un élément dans un Shell

Sylvain — Fri, 06 Feb 2009 22:41:59 +0000

Ne vous est-il jamais arrivé d’avoir eu besoin de mettre en surbrillance un élément dans un shell suite à un « cat », un « tail », etc tout en conservant le contexte ?

Si la réponse est « oui », voici deux solutions du même acabit permettant de parvenir à vos fins :

1ère solution utilisant Perl

Nous allons définir une fonction bash nommée « hl » (pour highlight) prenant en paramètre une expression rationnelle compatible Perl (une « PCRE ») capturant l’élément à mettre en surbrillance :

user@gnusquad:~$ function hl(){ perl -pe "s/($1)/\e[1;42m\$1\e[0m/g" ; }

Voici quelques exemples d'utilisation :

user@gnusquad:~$ echo "GNU Squad" | hl GNU
GNU Squad

user@gnusquad:~$ echo "GNU Squad" | hl S.+d
GNU Squad

root@gnusquad:~# tail -f /var/log/apache2/access.log | hl 192.168.[0-9]+.[0-9]+
192.168.0.3 - - [06/Feb/2009:22:51:18 +0100] "GET / HTTP/1.1" 304 - "http://blog.gnusquad.org/" ""

Je vous invite à lire le billet « Mettez de la couleur dans votre prompt » si vous souhaitez changer la couleur de surbrillance.

2ème solution utilisant grep

Même principe que précédemment : nous allons définir une fonction bash nommée « hl » prenant en paramètre une expression rationnelle compatible POSIX capturant l’élément à mettre en surbrillance :

user@gnusquad:~$ function hl(){ grep --color -C1000000 -E $1 ; }

Le résultat étant le même que la solution précédente, pas besoin de nouveaux exemples.

Notez cependant que cette solution est moins propre que la première à cause de l’option -C qui utilise un nombre magique (en fait celui-ci correspond au nombre de lignes à afficher avant et après le motif trouvé) mais est en contrepartie plus facile à lire…

Il ne vous reste plus qu’à mettre cette fonction dans votre fichier ~/.bashrc et le tour est joué !

À lire :

Faites taire votre PC Speaker !

Sylvain — Thu, 05 Feb 2009 13:20:57 +0000

Quoi de plus énervant que de se faire agresser par le PC Speaker lors d’une erreur, d’une completion automatique dans bash ou que sais-je encore ? Je vais vous présenter plusieurs solutions pour le faire taire à jamais :

Empêcher le module noyau dédié au PC Speaker de se charger :

root@gnusquad:~# echo "install pcspkr /bin/true" > /etc/modprobe.d/pcspkr

Il est également possible d’ignorer le chargement du module mais la première méthode est la méthode conseillée en cas de module récalcitrant :

root@gnusquad:~# echo "blacklist pcspkr" > /etc/modprobe.d/pcspkr

Il se peut que le module à désactiver ne soit pas « pcspkr » mais « snd_pcsp », à vous de tester avec « rmmod xxx » qui déchargera le module en live.

Désactiver les beeps sous X11 :

user@gnusquad:~$ xset b off

Vous pouvez également ajouter cette commande dans votre fichier « ~/.xinitrc » pour qu’elle soit lancée automatiquement au démarrage de X11.

Désactiver les beeps sous une console tty

user@gnusquad:~$ setterm -blength 0

Vous pouvez également ajouter cette commande dans votre fichier « ~/.bashrc » pour qu’elle soit lancée automatiquement lorsque vous vous authentifiez.

Désactiver les beeps pour les programmes utilisant la bibliothèque « readline » :

user@gnusquad:~$ echo "set bell-style none" >> ~/.inputrc

À lire :

Forcer la vérification des partitions au démarrage

Sylvain — Fri, 19 Dec 2008 11:27:59 +0000

Si vous souhaitez forcer la vérification des partitions (le fameux « fsck ») au prochain démarrage de votre Debian, rien de plus simple, il suffit de créer le fichier « forcefsck » à la racine :

root@gnusquad:~# > /forcefsck

Celui-ci sera automatiquement supprimé une fois la vérification effectuée.

L’inverse est également possible en créant le fichier « fastboot » à la racine :

root@gnusquad:~# > /fastboot

Notez au passage, que la commande « shutdown » peut également faire ce travail en lui passant les paramètres « -F » pour forcer la vérification au démarrage et « -f » pour avoir un démarrage rapide, sans « fsck ».

À lire :

Limiter le temps d’exécution d’une requête MySQL

Sylvain — Thu, 27 Nov 2008 12:03:54 +0000

Vous est-il déjà arrivé de voir un de vos serveurs de base de données MySQL mis à genoux par la faute de développeurs incompétents qui effectuent des requêtes sur des tables sans index composées de dizaines de millions de tuples ?
Si la réponse est oui, voici ma solution « one line » pour les calmer un peu !

Logiciels utilisés :

GNU Awk 3.1.5
MySQL Client 5.0.51a

root@gnusquad:~# mysql -e 'SHOW PROCESSLIST' | awk 'BEGIN { MAX_TIME = 60 ; USERS = "boulet1|boulet2" } $6 > MAX_TIME && $5 == "Query" && $2 ~ USERS {print "KILL " $1 ";"}' | mysql

Petites explications sur le code « awk » :

$1 contient l’ID de la requête SQL
$2 contient le nom de l’utilisateur
$5 contient le type de commande (Query, Sleep, …)
$6 contient le temps d’exécution de la requête SQL en secondes
MAX_TIME contient le temps en secondes à partir duquel une requête doit être tuée
USERS contient une expression rationnelle indiquant les utilisateurs concernés par cette sanction

Il ne vous reste plus qu’à mettre ce script dans le « crontab » en pensant à vous connecter avec un utilisateur MySQL ayant le droit « SUPER » pour pouvoir tuer les connexions si besoin est.

À lire :

Man page de gawk

Mettez de la couleur dans votre « prompt » !

Sylvain — Sat, 22 Nov 2008 16:26:01 +0000

Le « prompt », que l’on désigne par « invite de commande » en français est une chaîne de caractères indiquant que l’ordinateur est prêt à recevoir une saisie au clavier.

Les informations qui suivent concernent le shell livré par défaut avec la plupart des distributions, le bien nommé « Bash ».

Le « prompt » est défini dans une variable d’environnement nommée « PS1 », celle-ci peut contenir des données statiques mais également des « séquences d’échappement » spéciales permettant d’afficher des données dynamiques comme le nom d’utilisateur courant, le répertoire courant, etc. Il est également possible de mettre de la couleur afin d’égayer un peu votre terminal et surtout de vous retrouvez dans vos différents comptes utilisateurs ou dans vos différentes machines.

Voici la liste des séquences d’échappement intéressantes :

\h : le nom de la machine (hostname) jusqu'au premier point
\H : le nom de la machine complet
\j : le nombre de processus fils lancés en arrière plan
\e : caractère d'échappement (utile pour les couleurs)
\n : nouvelle ligne
\r : retour chariot
\u : le nom d'utilisateur courant
\w : le chemin complet du répertoire de travail courant
\W : le répertoire de travail courant
\$ : affiche un # si l'utilisateur est root sinon affiche un $
\[ : début d'une séquence de caractères non imprimables
\] : fin d'une séquence de caractères non imprimables
\D{format} : la date selon le format passé en paramètre (cf. la syntaxe de « strftime »)

Les couleurs quant à elles sont des « séquences d’échappement ANSI » entourées d’un début et d’une fin de séquence de caractères non imprimables. Ces séquences ont un format bien déterminé : celui-ci commence par « ESC[ » et se termine par « m ». Entre ces deux parties, il faut indiquer un code de mise en forme (gras, souligné, clignotement, etc) ainsi qu'un code pour la couleur désirée, les deux champs étant séparés par un point-virgule.

Voici la liste des mises en forme les plus courantes :

 0 : normal
 1 : gras
 4 : souligné
 5 : clignotement
 7 : négatif
22 : désactivation du gras
24 : désactivation du souligné
25 : désactivation du clignotement

Et la liste des couleurs :

0 : noir
1 : rouge
2 : vert
3 : jaune
4 : bleu
5 : magenta
6 : cyan
7 : blanc

À ces dernières doit être additionné un nombre afin de définir si l'on veut modifier la couleur du fond ou du texte tout en réglant l'intensité :

 30 : couleur du texte, intensité normale
 40 : couleur du fond, intensité normale
 90 : couleur du texte, intensité élevée
100 : couleur du fond, intensité élevée

Pour voir votre PS1 actuel, tapez simplement dans un shell :

user@gnusquad:~$ echo $PS1
\[\e[1;42m\]\u@\H\[\e[0;40m\]:\w\$

Décortiquons cette ligne :

\[   : début d'une séquence de caractères non imprimables (pour la couleur)
\e[  : début d'une séquence ANSI
1;42 : mise en forme grasse avec une couleur de fond verte intensité normale
m    : fin d'une séquence ANSI
\]   : fin d’une séquence de caractères non imprimables
\u   : nom d'utilisateur courant
@    : signe @
\H   : nom de la machine complète
\[   : début d'une séquence de caractères non imprimables
\e[  : début d'une séquence ANSI
0;40 : mise en forme normale avec une couleur de fond noir intensité normale
m    : fin d'une séquence ANSI
\]   : fin d’une séquence de caractères non imprimables
:    : signe :
\w   : chemin complet du répertoire de travail courant
\$   : caractère # si l'utilisateur est root sinon caractère $

Pour tester vos créations (ici un fond rouge qui peut être pratique pour l'utilisateur « root »), il vous suffira de taper dans un shell :

user@gnusquad:~$ PS1='\[\e[1;41m\]\u@\H\[\e[0;40m\]:\w\$'
user@gnusquad:~$

Une fois satisfait de votre « PS1 », vous n'aurez plus qu'à le mettre dans le fichier « /etc/bash.bashrc » (pour tous les utilisateurs) ou dans votre fichier « ~/.bashrc » (pour vous uniquement).

Notez au passage qu'il existe aussi trois autres variables d'environnement « PS2 », « PS3 » et « PS4 » que je vous laisse découvrir dans le man de bash !

N'hésitez pas à proposer vos « prompt » en commentaires !

À lire :