12.9. Commandes diverses

Commandes qui ne peuvent être classées

jot, seq

Ces outils génèrent des séquences de nombres entiers avec une incrémentation choisie par l'utilisateur.

Le retour à la ligne qui sépare habituellement les entiers peut être modifié avec l'option -s.

bash$ seq 5 1 2 3 4 5 bash$ seq -s : 5 1:2:3:4:5

jot et seq sont fort pratiques pour les boucles.

Exemple 12-39. Utiliser seq pour générer l'incrément d'une boucle

#!/bin/bash # Utiliser "seq" echo for a in `seq 80` # ou for a in $( seq 80 ) # Identique à for a in 1 2 3 4 5 ... 80 (évite beaucoup de frappe!). # Pourrait aussi utiliser 'jot' (si présent sur le système). do echo -n "$a " done # 1 2 3 4 5 ... 80 # Exemple d'utilisation de la sortie d'une commande pour générer la [liste] # dans une boucle "for". echo; echo COMPTEUR=80 # Oui, 'seq' peut aussi prendre un compteur remplaçable. for a in `seq $COMPTEUR` # ou for a in $( seq $COMPTEUR ) do echo -n "$a " done # 1 2 3 4 5 ... 80 echo; echo DEBUT=75 FIN=80 for a in `seq $DEBUT $FIN` # Donner à "seq" deux arguments permet de commencer le comptage au premier et #+ de le terminer au second. do echo -n "$a " done # 75 76 77 78 79 80 echo; echo DEBUT=45 INTERVALLE=5 FIN=80 for a in `seq $DEBUT $INTERVALLE $FIN` # Donner à "seq" trois arguments permet de commencer le comptage au premier, #+ d'utiliser le deuxième comme intervalle et de le terminer au troisième. do echo -n "$a " done # 45 50 55 60 65 70 75 80 echo; echo exit 0

getopt

La commande getopt analyse les paramètres de la ligne de commande précédés par un tiret. Cette commande externe correspond à une version moins souple de la commande interne getopts .

Exemple 12-40. Utiliser getopt pour analyser les paramètres de la ligne de commande

#!/bin/bash # Essayez ce qui suit lors de l'appel à ce script. # sh ex33a -a # sh ex33a -abc # sh ex33a -a -b -c # sh ex33a -d # sh ex33a -dXYZ # sh ex33a -d XYZ # sh ex33a -abcd # sh ex33a -abcdZ # sh ex33a -z # sh ex33a a # Expliquez les résultats de chacun. E_OPTERR=65 if [ "$#" -eq 0 ] then # Le script a besoin d'un argument en ligne de commande. echo "Usage $0 -[options a,b,c]" exit $E_OPTERR fi set -- `getopt "abcd:" "$@"` # Positionne les paramètres de position par rapport aux arguments en ligne de #+ commandes. # Qu'arrive-t'il si vous utilisez "$*" au lieu de "$@"? while [ ! -z "$1" ] do case "$1" in -a) echo "Option \"a\"";; -b) echo "Option \"b\"";; -c) echo "Option \"c\"";; -d) echo "Option \"d\" $2";; *) break;; esac shift done # Il est mieux d'utiliser la commande intégrée 'getopts' dans un script, #+ plutôt que 'getopt'. # Voir "ex33.sh". exit 0

run-parts

La commande run-parts [1] exécutent tous les scripts d'un répertoire cible triés par ordre ASCII. Evidement, ces scripts nécessitent les droits d'exécution.

Le démon crond lance run-parts pour exécuter les scripts du répertoire /etc/cron.*.

yes

Par défaut , la commande yes envoie une suite infinie de lettres y suivies de retours à la ligne sur stdout. Un ctrl-c arrête l'éxécution. Une chaîne différente peut être spécifiée en argument (yes chaine_differente affichera continuellement chaine_differente sur stdout). On pourrait se demander l'intérêt de la chose. En pratique, yes peut être utilisé comme un expect minimaliste en étant redirigé vers un programme en attente d'une saisie expect.

yes | fsck /dev/hda1 confirme toutes les réparations à fsck (méfiance!).

yes | rm -r dirname aura le même effet que rm -rf dirname (toujours méfiance!).

La plus grande prudence est conseillée lorsque vous redirigez yes vers une commande potentiellement dangereuse pour votre système, comme fsck ou fdisk. Cela pourrait avoir des effets secondaires inattendus.

banner

affiche les paramètres sur stdout comme une grande bannière verticale en utilisant un symbole ASCII ( # par défaut ). On peut rediriger cette sortie vers l'imprimante pour obtenir une copie papier.

printenv

Montre toutes les variables d'environnement réglées pour un utilisateur donné.

bash$ printenv | grep HOME HOME=/home/bozo

lp

Les commandes lp et lpr envoient un (des) fichier(s) à la file d'impression. [2] Ces commandes tirent l'origine de leurs noms des imprimantes "ligne par ligne" d'un autre âge.

bash$ lp file1.txt ou bash lp <file1.txt

Il est souvent utile d'envoyer le résultat de la commande pr à lp.

bash$ pr -options file1.txt | lp

Les outils de mise en forme comme groff et Ghostscript peuvent directement envoyer leurs sorties à lp.

bash$ groff -Tascii file.tr | lp

bash$ gs -options | lp file.ps

Les commandes sont lpq pour visualiser la file d'impression et lprm pour retirer des documents de la file d'impression.

tee

[UNIX emprunte ici une idée aux commerces de tuyauterie]

C'est un opérateur de redirection avec une petite différence : comme le << T >> du plombier, il permet de << renvoyer >> vers un fichier la sortie d'une commande ou de plusieurs commandes à l'intérieur d'un tube mais sans affecter le résultat. Ceci est utile pour envoyer le résultat du processus en cours vers un fichier ou un papier, par exemple pour des raisons de déboguages.

tee |------> vers le fichier | ===============|=============== commande--->----|-operateur-->---> résultats des commandes ===============================

cat listefichiers* | sort | tee fichier.verif | uniq > fichier.resultat

(le fichierfichier.verif contient les contenus concaténés puis triés des fichiers << listefichiers >> avant que les doublons ne soient supprimés par uniq.)

mkfifo

Cette commande obscure crée un tube nommé, un tampon temporaire pour transférer les données entre les programmes sur le principe du first-in-first-out (FIFO : premier arrivé, premier sorti) [3] Classiquement, un programme écrit dans le FIFO et un autre y lit. Voir Exemple A-16.

pathchk

Ce programme vérifie la validité d'un nom de fichier. Il renvoie un message d'erreur si le nom excède la taille maximale autorisée (255 caractères) ou si un des répertoires du chemin est inaccessible, alors un message d'erreur est affiché.

Malheureusement, pathchk ne renvoie pas un code d'erreur interprétable, ce qui le rend assez inutile dans un script. Cherchez du côté des opérateurs de tests sur les fichiers si besoin.

dd

C'est une commande légèrement obscure et l'une des plus craintes des commandes de duplication des données. A l'origine, c'était un outil d'échange de données entre les bandes magnétiques des mini-ordinateurs unix et les mainframes d'IBM. Cette commande est encore utilisée à cet effet. dd copie simplement un fichier (ou stdin/stdout) mais en effectuant une conversion. ASCII/EBCDIC est une conversion possible [4] minuscule/majuscule, permutation des paires d'octets entre l'entré et la sortie, saut et troncature des entêtes et queues du fichier d'entrées, un dd --help affichera la liste des autres conversions possibles de ce puissant programme.

# S'exercer à 'dd'. n=3 p=5 fichier_entree=projet.txt fichier_sortie=traces.txt dd if=$fichier_entree of=$fichier_sortie bs=1 skip=$((n-1)) count=$((p-n+1)) 2> /dev/null # extrait les symboles de n à p du fichier $fichier_entree echo -n "bonjour le monde" | dd cbs=1 conv=unblock 2> /dev/null # affiche "bonjour le monde" verticalement. # Merci, S.C.

Pour montrer a quel point dd est souple, utilisons le pour capturer nos saisies.

Exemple 12-41. Capturer une saisie

#!/bin/bash # Capture des touches clavier sans avoir besoin d'appuyer sur ENTER. touches_appuyees=4 # Nombre de touches à capturer. ancien_parametrage_du_tty=$(stty -g) # Sauve l'ancienne configuration du terminal. echo "Appuyez sur $touches_appuyees touches." stty -icanon -echo # Désactive le mode canonique. # Désactive l'echo local. touches=$(dd bs=1 count=$touches_appuyees 2> /dev/null) # 'dd' utilise stdin si "if" n'est pas spécifié. stty "$ancien_parametrage_du_tty" # Restaure l'ancien paramètrage du terminal. echo "Vous avez appuyé sur les touches \"$keys\"." # Merci, S.C. pour avoir montré la façon. exit 0

dd peut effectuer un accès aléatoire sur un flux de données.

echo -n . | dd bs=1 seek=4 of=fichier conv=notrunc # l'option "conv=notrunc" signifie que la sortie ne sera pas tronquée. # Merci, S.C.

dd peut copier les données brutes d'un périphérique (comme un lecteur de disquette ou de bande magnétique) vers une image et inversement (Exemple A-6). On l'utilise couramment pour créer des disques de démarage.

dd if=kernel-image of=/dev/fd0H1440

De la même manière, dd peut copier le contenu entier d'un disque (même formaté avec un autre OS) vers un fichier image.

dd if=/dev/fd0 of=/home/bozo/projects/floppy.img

Comme autres exemples d'applications de dd, on peut citer l'initialisation d'un fichier swap temporaire (Exemple 29-2) ou d'un disque en mémoire (Exemple 29-3). dd peut même effectuer la copie bas-niveau d'une partition complète d'un disque dur même si la pratique n'est pas conseillée.

Les gens (qui n'ont probablement rien à faire de mieux de leur temps) pensent constamment à de nouvelles applications intéressantes de dd.

Exemple 12-42. Effacer les fichiers de façon sure

#!/bin/bash # blotout.sh: Efface toutes les traces d'un fichier. # Ce script écrase un fichier cible avec des octets pris au hasard, puis avec #+ des zéros, avant de le supprimer définitivement. # Après cela, même l'examen des secteurs du disque ne permet pas de retrouver #+ les données du fichier d'origine. PASSES=7 # Nombre d'écriture sur le fichier. TAILLEBLOC=1 # Les entrées/sorties avec /dev/urandom requièrent la taille #+ d'un bloc, sinon vous obtiendrez des résultats bizarres. E_MAUVAISARGS=70 E_NON_TROUVE=71 E_CHANGE_D_AVIS=72 if [ -z "$1" ] # Aucun nom de fichier spécifié. then echo "Usage: `basename $0` nomfichier" exit $E_MAUVAISARGS fi fichier=$1 if [ ! -e "$fichier" ] then echo "Le fichier \"$fichier\" est introuvable." exit $E_NON_TROUVE fi echo; echo -n "Etes-vous absolument sûr de vouloir écraser complètement \"$fichier\" (o/n)? " read reponse case "$reponse" in [nN]) echo "Vous avez changé d'idée, hum?" exit $E_CHANGE_D_AVIS ;; *) echo "Ecrasement du fichier \"$fichier\".";; esac longueur_fichier=$(ls -l "$fichier" | awk '{print $5}') # Le 5e champ correspond à la taille du fichier. nb_passe=1 echo while [ "$nb_passe" -le "$PASSES" ] do echo "Passe #$nb_passe" sync # Vider les tampons. dd if=/dev/urandom of=$fichier bs=$TAILLEBLOC count=$longueur_fichier # Remplir avec des octets pris au hasard. sync # Vider de nouveau les tampons. dd if=/dev/zero of=$fichier bs=$TAILLEBLOC count=$longueur_fichier # Remplir avec des zéros. sync # Vider encore une fois les tampons. let "nb_passe += 1" echo done rm -f $fichier # Finalement, la suppression a complètement écrasé le fichier. sync # Vide les tampons une dernière fois. echo "Le fichier \"$fichier\" a été complètement écrasé et supprimé."; echo # C'est une méthode assez sécurisée, mais inefficace et lente pour massacrer #+ un fichier. La commande "shred", faisant partie du paquetage GNU "fileutils", #+ fait la même chose mais de façon plus efficace. # Le fichier ne peut pas être récupéré par les méthodes habituelles. # Néanmoins... #+ cette simple méthode ne pourra certainement *pas* résister à des #+ plus poussées. # Le paquetage de suppression de fichier "wipe" de Tom Vier fait un travail #+ bien plus en profondeur pour massacrer un fichier que ce simple script. # http://www.ibiblio.org/pub/Linux/utils/file/wipe-2.0.0.tar.bz2 # Pour une analyse en détail du thème de la suppression de fichier et de la #+ sécurité, voir le papier de Peter Gutmann, #+ "Secure Deletion of Data From Magnetic and Solid-State Memory". # http://www.cs.auckland.ac.nz/~pgut001/secure_del.html exit 0

od

Le filtre od (pour octal dump) convertit l'entré en octal (base 8) ou dans une autre base. C'est très utile pour voir ou traiter des fichiers binaires ou d'autres sources de données illisibles comme /dev/urandom. Voir Exemple 9-26 et Exemple 12-10.

hexdump

Effectue une image hexadécimale, octale, décimale ou ASCII d'un fichier binaire. hexdump est un équivalent moins complet d' od, traité ci-dessus.

objdump

Affiche un objet ou un exécutable binaire sous sa forme hexadécimale ou en tant que code désassemblé (avec l'option -d).

bash$ objdump -d /bin/ls /bin/ls: file format elf32-i386 Disassembly of section .init: 080490bc <.init>: 80490bc: 55 push %ebp 80490bd: 89 e5 mov %esp,%ebp . . .

mcookie

Cette commande génère un fichier témoin (<< magic cookie >>), un nombre hexadécimal pseudo-aléatoire de 128 bits (32 caractères) qui est habituellement utilisé par les serveurs X comme << signature >> pour l'authentification. Elle peut être utilisée dans un script comme une solution sale mais rapide pour générer des nombres aléatoires.

random000=`mcookie | sed -e '2p'` # Utilise sed pour supprimer les symbôles en trop

Evidemment, un script peut utiliser md5 pour obtenir le même résultat.

# Génère la somme de contrôle md5 du script lui-même. random001=`md5sum $0 | awk '{print $1}'` # Utilise awk pour supprimer le nom du fichier

mcookie est aussi une autre facon de générer un nom de fichier << unique >>.

Exemple 12-43. Générateur de nom de fichier

#!/bin/bash # tempfile-name.sh: générateur de fichier temporaire. BASE_STR=`mcookie` # Chaîne magique de 32 caractères. POS=11 # Position arbitraire dans la chaîne magique. LONG=5 # Pour obtenir $LONG caractères consécutifs. prefixe=temp # C'est après tout un fichier "temp"oraire. # Pour que le nom soit encore plus "unique", génère le #+ préfixe du nom du fichier en utilisant la même méthode #+ que le suffixe ci-dessous. suffixe=${BASE_STR:POS:LONG} # Extrait une chaîne de cinq caractères, commençant à la # position 11. nomfichiertemporaire=$prefixe.$suffixe # Construction du nom du fichier. echo "Nom du fichier temporaire = "$nomfichiertemporaire"" # sh tempfile-name.sh # Nom du fichier temporaire = temp.e19ea exit 0

units

Généralement appelé de façon interactive, cet utilitaire peut être utilisé dans un script. Il sert à convertir des mesures en différentes unités.

Exemple 12-44. Convertir des mètres en miles

#!/bin/bash # unit-conversion.sh convertir_unites () # Prend comme arguments les unités à convertir. { cf=$(units "$1" "$2" | sed --silent -e '1p' | awk '{print $2}') # Supprime tous sauf le facteur conversion. echo "$cf" } Unite1=miles Unite2=meters facteur_conversion=`convertir_unites $Unite1 $Unite2` quantite=3.73 resultat=$(echo $quantite*$facteur_conversion | bc) echo "Il existe $resultat $Unite2 dans $quantite $Unit1." # Que se passe-t'il si vous donnez des unités incompatibles, telles que #+ "acres" et "miles"? exit 0

m4

Trésor caché, m4 est un puissant filtre de traitement des macros. [5] Langage pratiquement complet, m4 fut écrit comme pré-processeur pour RatFor avant de s'avérer être un outil autonome très utile. En plus de ses possibilités étendues d'interpolation de macros, m4 intègre les fonctionnalités d'eval, tr et awk.

Un très bon article sur m4 et ses utilisations a été écrit pour le numéro d'avril 2002 du Linux Journal.

Exemple 12-45. Utiliser m4

#!/bin/bash # m4.sh: Utiliser le processeur de macros m4 # Chaîne de caractères chaine=abcdA01 echo "len($chaine)" | m4 # 7 echo "substr($chaine,4)" | m4 # A01 echo "regexp($chaine,[0-1][0-1],\&Z)" | m4 # 01Z # Arithmétique echo "incr(22)" | m4 # 23 echo "eval(99 / 3)" | m4 # 33 exit 0

doexec

doexec permet de transmettre une liste arbitraire d'arguments à un binaire exécutable. En particulier , le fait de transmettre argv[0] (qui correspond à $0 dans un script) permet à l'exécutable d'être invoqué avec des noms différents et d'agir en fonction de cette invocation. Ceci n'est qu'une autre façon de passer des options à un exécutable.

Par exemple , le répertoire /usr/local/bin peut contenir un binaire appelé << aaa >>. doexec /usr/local/bin/aaa list affichera la liste de tous les fichiers du répertoire courant qui commencent par un << a >>. Appeler le même binaire par doexec /usr/local/bin/aaa delete détruira ces fichiers.

Les différentes actions d'un executable doivent être définies à l'interieur du code exécutable lui-même. De façon similaire au script suivant : case `basename $0` in "name1" ) faire_qqchose;; "name2" ) faire_qqchose_d_autre;; "name3" ) encore_autre_chose;; * ) quitter;; esac