1 - Faites deux scripts qui vous disent bonjour en affichant votre login («Bonjour, toto») :

            - Quand vous tapez saluer [votre-login]

            - Quand vous tapez juste saluer

Il faut éditer un fichier saluer et le rendre ensuite éxécutable :

1 #!/bin/sh
2 if [ -n "$1" ]; then LOGIN=$1; else LOGIN=`whoami`; fi
3 echo "Bonjour, $LOGIN"

2 - Faire un script qui affiche la phrase : Le script [params] a [n] paramètre(s), que voici : [paramètres], en
remplaçant les mots entre crochets par leur valeur; par exemple :

                chaland ~ $ params bla ble bli blo blu

La commande params a 5 paramètre(s), que voici : bla ble bli blo blu

1 #!/bin/sh
2 echo "La commande $0 a $# paramètre(s), que voici| : $@"
3 - Créez une commande qui, lorsqu'elle est appelée, renvoie le nombre d'arguments qui lui ont été fournis, ainsi
que le premier de ces arguments.

1 #!/bin/sh
2 echo "J'ai reçu $# arguments"
3 echo "Le premier d'iceux est $1"

4 - Vous voulez écrire un script qui vous dit combien de personnes sont loguées sur une machine donnée; par
exemple :

                 drakkar ~ $ combien galion

Il y a 5 personne(s) loguées sur galion en ce moment.

                 drakkar ~ $

1 #!/bin/sh
2 N=`who | wc -l | sed -e "s/ *//"`
3 MACHINE=`whoami`
4 echo "Il y a $N personne(s) logués sur $MACHINE en ce moment"
5 - On veut remplacer le suffixe .htm d'un ensemble de fichiers en .html.

Le script suivant lancé avec "**/*.htm" comme paramètre devrait fonctionner :

1 #!/bin/sh
2 for i in $@;
3 do
4 mv $i `echo $i | sed -e "s/htm$/html/"`
5 done;

 
6 - Un ensemble de noms de fichiers sont en majuscules. On veut tout basculer en minuscules.

1 #!/bin/sh
2 for i in $@;
3 do
4 mv $i `echo $i | tr '[:upper:]' '[:lower:]'`
5 done;

7 - Créez un script indice qui affiche l'indice de son premier argument dans la liste des arguments suivants. Par
exemple,

indice toto tata titi toto tutu

renvoie l'indice de toto dans la liste tata titi toto tutu, c'est-à-dire 3.

1 #!/bin/sh
2 ARG=$1
3 shift
4 N=0
5 for i in $@;
6 do
7 N=`expr $N + 1`
8 [ x$ARG = x$i ] && echo $N
9 done;

8 - On ne s'intéresse ici qu'à des fichiers contenant un mot par ligne. Ecrire un script qui compte le nombre de
mots contenant une des lettres «r», «s» ou «t», et parmi eux, ceux qui ont au moins deux telles lettres. On
donnera aussi le nombre de mots ne contenant aucune voyelle. Cela donnera par exemple :

Dans ce fichier,  vous avez :

45 mots contenant «r», «s» ou «t», et parmi eux,

12 contiennent deux de ces lettres au moins.

Il y a aussi 10 mots ne contenant aucune voyelle.

1 #!/bin/sh
2 RST=`grep "[rst]" $1 | wc -l`
3 DEUX=`grep "[rst].*[rst]" $1 | wc -l`
4 CONS=`grep -v "[aeiou]" $1 | wc -l`
5 (echo "Dans ce fichier, vous avez| :";
6 echo "$RST mots contenant «r», «s» ou «t» et parmi eux,";
7 echo "$DEUX contiennent deux de ces lettres au moins.";
8 echo "Il y a aussi $CONS mots ne contenant aucune voyelle.") |
9 sed -e "2,3s/^ *//
1 \$s/i */i /"
0

9 - On veut chercher toutes les occurences des quatre éléments (terre, air, eau, feu) dans la première partie de
Germinal.
On veut aussi que le résultat soit placé dans un fichier, et que le résultat soit classé : toutes les lignes qui
contiennent «air», puis toutes celles qui contiennent «eau», etc.
#!/bin/sh
FICHIER=resultat
MOTS="terre air eau feu"
[ -w $FICHIER ] && echo "Le fichier $FICHIER existe déjà" && exit 1
for i in $MOTS;
do
echo "Lignes contenant $i" >> $FICHIER
grep $i zola*.txt >> $FICHIER
echo >> $FICHIER
done;
10 - Chercher le mot «mine» dans les chapitres 3, 4 et 5 de la première partie de Germinal, et obtenir un fichier
dans lequel figure le nombre d'occurences du mot dans les fichiers, avec le numéro des lignes.

1 #!/bin/sh
2 FICHIER=resultat
3 [ -w $FICHIER ] && echo "Le fichier $FICHIER existe déjà" && exit 1
4 for i in zola[345].txt;
5 do
6 echo "Dans le fichier $i, voici les lignes contenant «mine»" >> $FICHIER
7 NB=`grep -n mine $i | tee -a $FICHIER | wc -l`
8 (echo "$NB lignes";echo ) >> $FICHIER
9 done;

11 - Créez un script coupe qui prend trois arguments, le premier étant un nom de fichier et les deux autres des
entiers l et l', et qui affiche les lignes comprises entre l et l' dans le fichier. Par exemple,

coupe fic 4 8

affichera les lignes 4 à 8 du fichier fic. Affichez des messages en cas d'erreur (nombre de paramètres incorrect,
fichier inexistant, etc).

1 #!/bin/sh
2 [ $# != "3" ] && echo "Nombre de paramètres incorrects" && exit 1
3 [ ! -r $1 ] && echo "Fichier $1 inexistant" && exit 1
4 cat $1 | sed -n -e "$2,$3p"

12 - Pour transformer une arborescence en un seul fichier compressé, on utilise l'instruction

             tar zcvf nouveaunom fichiersaregrouper

Avant d'envoyer des fichiers tar, on utilise uuencode.

Ecrivez une commande tarmail qui prend deux arguments, une adresse et un nom de répertoire, et qui envoie par
mail le contenu de l'arborescence du répertoire précédée d'un message expliquant comment la récupérer.

Note : pour récupérer un fichier uuencodé, on tape uudecode et pour reconstruire l'arborescence, on utilise tar
zxvf fichier.

1 (echo "To: $1";

2 echo "Subject: $2";
3 echo " Pour lire ce document, sauvegardez ce mail (par exemple sous le "
4 echo "nom bidule) et faites ";
5 echo "uudecode bidule | tar tvzf -";
6 echo "pour récupérer les fichiers du répertoire $2";
7 tar cvf - $2 | gzip | uuencode /dev/stdout) | mail $1

13 - La commande suivante affiche le path complet de tous les fichiers finissant par ~ (tilde) dans la sous-
arborescence du répertoire courant.

find . -name '*~'

   Ecrivez un script qui prend en argument un nom de répertoire et qui détruit tous les fichiers :

                 a- Finissant par ~;

                 b- Commençant et finissant par un dièse;

                 c- S'appelant core;

                 d- S'appelant a.out.

1 #!/bin/sh
2 for i in `find . \( -name '*~' -o -name 'core' -o -name 'a.out' -o -name '#*#' \) -type f` ;
3 do
4 rm -f $i
5 done;
14 - Ecrire un script permettant d'appliquer divers filtres sur un fichier. Ce script est lancé avec un argument, qui
doit être un nom de fichier appelé fichier de travail; dans le cas contraire, on affiche un message d'erreur. On
attend ensuite une commande en mode interactif, qui peut être :

   - end : le programme s'arrête;

   - cherche : le programme lit alors une ligne au clavier contenant un motif et une autre contenant un nom de
fichier, puis écrit dans ce fichier les lignes du fichier de travail contenant le motif;

   - tete oufin : le programme lit une ligne au clavier contenant un entier n puis une ligne contenant un nom de
fichier. Il écrit ensuite les n premières (resp. dernières) lignes du fichier de travail dans le fichier précisé;

   - autre chose : message d'erreur.

1 #!/bin/sh
2 if [ $# != "1" ]; then echo "Indiquez un nom de fichier";exit 1; fi
3 if [ ! -r $1 ]; then echo "Fichier $1 inexistant";exit 1; fi
4 TRAVAIL=$1
5 while true;
6 do
7 read CMD
8 case $CMD in
9 end) exit 0;;
10 cherche) echo -n "Motif ? ";read MOTIF;
11 echo -n "Fichier ? ";read FICHIER;
12 if [ -w $FICHIER ]; then
13 echo "Le fichier $FICHIER existe déjà";
14 else
15 grep $MOTIF $TRAVAIL > $FICHIER
16 fi
17 ;;
18 tete|fin)
19 echo -n "Lignes ? ";read LGN;
 20 echo -n "Fichier ? ";read FICHIER;
21 if [ -w $FICHIER ]; then
22 echo "Le fichier $FICHIER existe déjà";
23 else
24 case $CMD in
25 tete) head -n $LGN < $TRAVAIL > $FICHIER;;
26 fin) tail -n $LGN < $TRAVAIL > $FICHIER;;
27 esac
28 fi
29 ;;
30 *) echo "Commande inexistante";;
31 esac
32 done;
33  

Exercice script unix shell - processus -

L'objectif de cet exercice est de créer une commande ikill ne prenant pas d'argument mais demandant un
nom de programme à l'utilisateur et tuant ce programme. On utilisera les commandes tr -s ' ', cut, kill,
read, ps -fA, grep, grep -v et echo.

La commande affichera :

Quel processus voulez-vous supprimer ?

Vous rentrerez un nom de processus, par exemple emacs et tous les processus emacs seront supprimés.

1. Lire les pages de man des commandes utilisées.

2. Quels sont les greps qu'il faut effectuer sur la sortie de ps -fA pour ne conserver que le processus que l'on
souhaite tuer (essayer avec ps -fA | grep bash). Utilisez la variable $USER.
3. Stockez la liste de PID des processus à supprimer dans la variable $PID et affichez la.
4. Écrire la commande. N'oubliez pas de vérifier que la variable $PID n'est pas vide avant d'effectuer le kill.

Correction :

1 #!/bin/bash
2 echo -n "Quel processus voulez-vous supprimer ? "
3 read NAME
4 PID=`ps -Af | grep "$USER" | grep "$NAME" | grep -v grep | tr -s ' ' | cut -f 3 -d ' '`
5 if [ -z $PID ]
6 then
7 echo Pas de processus $NAME...
8 exit -1
9 fi
10 kill $PID
11