[5.2] Ligne de commandes – Cinquième et dernière partie ! Un peu de tout…. »Système »

(Bonjour et bienvenus pour la deuxième parties de ce dernier chapitre concernant la ligne de commandes. Ce chapitre sera accès sur le « système« .

Système :
Comment gérer les utilisateurs du système et leurs droits ? Comment gérer ses paquets logiciels ? Comment faire le ménage sur son disque dur ? Comment gérer les différents services du système ? Comment identifier précisément son matériel et ses capacités ? …

kvm-kernel.png (Image PNG, 800 × 579 pixels) - Mozilla Firefox

01 ) Gérer les utilisateurs de votre système et leurs permissions. 

Linux est un système multi-utilisateur, vous pouvez donc en créer autant que vous le souhaitez. Chacun peut en outre se voir doté de plus ou moins de droits sur le système, ce qui va déterminer les actions qui lui sont permises. Mais ça, c’est vous qui décidez !

01Avoir tout les droits ; sudo :

La création de nouveaux utilisateurs fait partie des tâches nécessitant les droits super-utilisateur du système (root), qui peuvent être acquis momentanément grâce à la commande sudo ; elle doit alors précéder la commande nécessitant ces privilèges. Vous devez saisir votre mot de passe utilisateur et vous pourrez exécuter des commandes en tant que root pendant un certain laps de temps (généralement 15 minutes par défaut).

root

Mais attention, pour pouvoir faire usage de sudo, l’utilisateur courant doit faire partie du fichier /etc/sudoers. Sous certaines distributions (comme Ubuntu), le premier utilisateur du système y est automatiquement inscrit. Sous d’autres distributions (comme Debian), il est nécessaire d’ajouter au préalable l’utilisateur au fichier sudoers. Pour l’éditer, on utilise la commande visudo, qui elle-même demande les droits de root…
On fait alors appel à la commande su (pour substitute user) sans option ni argument, qui contrairement à la commande sudo, octroie les droits d’administration à l’utilisateur pendant toute la durée de la session :

~$ su 
Mot de passe : 
~# visudo 

1

Dans le fichier /etc/sudoers, on s’intéresse à la section suivante :

# User privilege specification
root     ALL=(ALL:ALL) ALL

2

Cela signifie que l’utilisateur root, quelle que soit la machine (premier ALL), peut utiliser sudo pour lancer n’importe quel programme (troisième ALL), en tant que n’importe qui (deuxième ALL).

Pour que l’utilisateur « alice » puisse utiliser la commande sudo, on ajoute alors la ligne :

alice ALL=(ALL:ALL) ALL

À savoir que la commande sudo utilisée avec l’option -u suivie du nom d’un utilisateur du système permet d’agir en tant que n’importe quel autre utilisateur.

02Créer un utilisateur :

L’ajout d’un nouvel utilisateur « bob » s’effectue via la commande adduser :

~$ sudo adduser bob

6

Comme indiqué dans les lignes retournées par la commande, le répertoire personnel du nouvel utilisateur est crée dans /home. Ce nouveau compte est basé sur le contenu du répertoire /etc/skel/ qui représente le « squelette » de tous les nouveaux comptes : tout ce qui s’y trouve sera recopié par défaut dans le répertoire de chaque nouvel utilisateur. Dans la foulée, le système vous demande de saisir le mot de passe de l’utilisateur ; les autres informations demandées sont facultatives.

Le mot de passe de l’utilisateur peut être modifié à n’importe quel moment avec la commande passwd :

~$ sudo passwd bob

4

À savoir aussi que la commande passwd -l permet de verrouiller le compte utilisateur (-u pour le déverrouiller le compte).

~# passwd -l bob

5

~# passwd -u bob

5.1

Pour supprimer un compte utilisateur, on utilise la commande deluser :

~# deluser bob

7

03Qui (s’) est connecté ?

Lorsque plusieurs utilisateurs existent sur le système, vous pouvez savoir à tout moment quels sont les utilisateurs connectés à l’aide des commandes who ou finger (cette dernière est plus détaillée).

Les commandes last et lastb (cette dernière est à exécuter en tant que root) permettent respectivement de lister les derniers utilisateurs connectés au système et les dernières tentatives de connexion qui ont échoué. Cela peut par exemple permettre de relever une tentative d’intrusion non souhaitée.

~# who -a
~# finger
~# last -F

Pour plus d’info, tapez : who –help ; finger –help ; last .

8

04Modifier les permissions sur les fichiers :

Nous avons vu dans l’introduction (première partie) que chaque fichier du système appartenait à un utilisateur et à un groupe et que ces derniers, de même que tous les autres utilisateurs, avaient certaines autorisations sur ces fichiers : les droits de lecture (r), d’écriture (w), et/ou d’exécution (x). Si ces lettres sont présentes lorsque vous affichez les propriétés d’un fichier, cela signifie qu’elles accordent la permission qu’elles désignent ; un tiret signifie en revanche que la permission n’est pas accordée.

Pour modifier les droits sur un fichier, on utilise la commande chmod (pour change mode). Pour l’utiliser, il faut que vous soyez propriétaire du fichier en question, ou bien que vous soyez root. La syntaxe est la suivante :

chmod <qui?>+

superuser-superhero

<qui?> représente l’un ou plusieurs des caractères suivants :

u ; (pour user), le propriétaire du fichier
g ; (pour group), le groupe auquel est lié le fichier.
o ; (pour other), le reste du monde.
a ; (pour all), qui inclut les trois types précédents.

Les signes + ou permettent respectivement d’ajouter ou de supprimer un droit et représente l’un ou une combinaison des droits r, w ou x.

Par exemple :

~$ chmod u+x fichier.sh

9

Ces deux commandes permettent de rendre le fichier fichier.sh exécutable par son propriétaire.

À noter que pour attribuer ou modifier les droits d’un répertoire et de tout son contenu (fichiers et sous-répertoires compris), que ce soit en mode littéral ou numérique, il faut utiliser l’option -R .

05Changer de propriétaire :

Comme évoqué plus haut, chaque fichier est lié à un propriétaire et à un groupe. Il est possible de changer le propriétaire d’un fichier à l’aide de la commande chown (pour change owner). La syntaxe est la suivante (à exécuter en tant que root) :

chown <nom_propriétaire> <fichiers_ou_répertoire>

La commande chown permet aussi de changer simultanément le propriétaire et le groupe du fichier, comme ceci :

chown <nom_propriétaire>: <fichier_ou_répertoire>

Par exemple :

~# chown -R www-data:www-data un_repertoire/

Notez l’utilisation de l’option -R ici, qui à nouveau, implique la récursivité de l’opération. Pour changer uniquement le groupe auquel appartient le fichier, on utilisera la commande chgrp (pour change group) :

chgrp <fichiers_ou_répertoire>

10

02 ) Gérer les paquets logiciels de sa distribution .

À chaque distribution correspond un format de paquet logiciel et chacune intègre son propre gestionnaire de paquets. Apt, Yum, Zypper, …, ils ont tous pour point commun de gérer également les dépendances entre paquets, ce qui facilite grandement l’installation de logiciels supplémentaires. Encore faut-il connaître les commandes adéquates.

apt-get

01Synchroniser le gestionnaire de paquets :

Pour que votre gestionnaire de paquets soit totalement synchrone avec le contenu des dépôts de votre distribution, il faut régulièrement mettre à jour l’index des paquets (et aussi dès que vous effectuez une modification quelconque dans la définition des dépôts.)

Sous Debian/Ubuntu :

~# aptitude update
ou
~# apt-get update
ou encore :
~# apt update && apt list –upgradable

Chez Fedora :

~# yum makecache

L’équivalent chez OpenSUSE correspond à :

~# zypper refresh 

02Mise à jour des paquets installés :

Sous Debian/Ubuntu, ceci s’effectue via la commande :

~# aptitude safe–upgrade 

11

Elle retourne la liste des changements qui vont être effectués (installations, suppressions de paquets obsolètes et mise à jour) et attend confirmation de votre part pour s’exécuter.

Sous Fedora et OpenSUSE :

~# yum update
~# zypper update

03 Rechercher un paquet :

Pour rechercher un paquet dans les dépôts d’une distribution Debian/Ubuntu :

~# aptitude search

12

Cette commande retourne une liste de paquets comportant le motif passé en paramètre dans leur nom et/ou dans leur description. Le premier caractère de chaque ligne indique l’état courant du paquet :

p ; signifie qu’il n’y a aucune trace du paquet sur le système.
c ; signifie que le paquet a été supprimé, mais que ses fichiers de configuration sont toujours présents sur le système.
i ; signifie que le paquet est installé.
v ; signifie que le paquet est virtuel.

Pour obtenir plus d’informations sur un paquet avant de l’installer, notamment sa description et la liste de ses dépendances :

~# aptitude show

13

04Installer un nouveau paquet :

Sur les systèmes type Debian/Ubuntu, on installera un paquet via la commande :

~# aptitude install

14

Si vous récupérez un paquet DEB manuellement ou via l’utilitaire wget, il vous faudra utiliser dpkg pour l’installer :

15

16

~# dpkg -i paquet.deb
(ou –install)

17

Mais attention ! N’oubliez pas que dpkg ne résout pas les dépendances !

Pour un paquet RPM, on utilisera :

~# rpm -ivh paquet.rpm

L’installation est réalisée avec l’option pour -i, l’option -v active le mode verbeux et l’option -h  permet de visualiser les barres de progression. Attention, ici encore, la résolution des dépendances n’est pas prise en charge par rpm.

05 Recherche les fichiers installés :

Pour visualiser l’ensemble des fichiers d’un paquet qui ont été installés et leur emplacement, on exécutera :

~$ dpkg -L

18

06 Supprimer un paquet :

Lors de la suppression d’un paquet, les dépendances sont également supprimées, sauf si elles sont nécessaires à d’autres paquets bien entendu.
Pour supprimer un paquet, il nous faut exécuter :

~# aptitude remove

Si vous souhaitez supprimer par la même occasion les fichiers de configuration propres au logiciel en question, il faudra utiliser l’option purge :

~# aptitude purge

aptitude
.
03 ) Connaître son système et identifier son matériel.

Vous venez d’acheter un nouvel ordinateur, votre installation Linux est toute fraîche. Bien sûr vous avez vaguement en tête les caractéristiques techniques de la machine en question, mais « vaguement » ce n’est parfois pas suffisant pour configurer au mieux son système. Voici une sélection de quelques commandes incontournables pour pallier ce problème.

01Votre système : version et fonctionnalités :

Pour connaître la version du noyau utilisé, ainsi que le nom de la machine et le type de processeur :

~$ uname -a

19

Pour obtenir des informations spécifiques à votre distribution, vous pouvez utiliser la commande lsb_release (« lsb » pour Linux Standard Base) accompagnée de l’option -a :

~$ lsb_release -a 

20

La liste des modules chargés par le noyau et leurs dépendances s’obtient via la commande lsmod. La commande modinfo suivie du nom d’un module permet d’obtenir des informations détaillées sur ce dernier :

~$ modinfo i2c-dev

21

02Le processeur :

Pour obtenir toutes les informations concernant le/les processeur(s) de votre machine (nom du fabricant,modèle,fréquence,ect),on étudiera le contenu du fichier /proc/cpuinfo :

~$ cat /proc/cpuinfo

22

03La mémoire :

La commande free retourne les quantités totales de RAM et de swap, libres et utilisées, ainsi que la mémoire partagée et les tampons (buffers) utilisés par le noyau. L’option -h permet d’exprimer les valeurs avec les unités les plus adéquates (pour une meilleur lisibilité) ; l’option -t permet d’afficher une ligne supplémentaire comportant la somme des deux types de mémoire.

~$ free -ht

23

04Les disques :

► Pour récupérer le descriptif détaillé d’un disque :

~# hdparm -I /dev/sda

24

L’utilitaire hdparm (à exécuter en tant que root) permet d’interagir avec les disques reliés à des contrôleurs SATA/IDE (disques durs, lecteurs CD/DVD, graveurs,ect). La première ligne retournée par la commande nous renseigne sur le modèle du disque. L’option -I permet d’obtenir davantage d’informations, classées par type. L’option -t permettra quant à elle de tester la vitesse de lecture de votre disque sur 3 secondes :

~# hdparm -t /dev/sda

25

► la commande df retourne l’espace disponible sur chaque partition. Comme plus haut. On utilisera l’option -h pour un format plus « lisible » ; l’option -T permet quant à elle d’afficher le type de système de fichiers :

~$ df -hT

26

(changement de couleur du texte …. J’espère que ça vous dérangera pas ? (surtout, n’hésitez pas à me donner votre avis sur la couleur pour une meilleur lisibilité. Merci.))

► la commande du permet de visualiser la taille d’un répertoire (de façon récursive) ou de l’ensemble de votre système de fichiers. Pour les grosses arborescences, pensez à utiliser l’option -s qui n’affiche que la taille total.

27

► la commande fdisk -l permet de lister les partitions du disque passé en argument, leur système de fichiers et leur taille.

~$ fdisk -l
~$ fdisk -l /dev/sda

28

► Pour connaître le point de montage des systèmes de fichiers montés, on utilisera simplement la commande  mount sans option ni argument.

~$ mount

29

S.M.A.R.T (Self-Monitoring, Analysis and Reporting Technology) est un système de surveillance aujourd’hui intégré dans tous les disques durs ATA et SCSI modernes. Le paquet smartmontools fournit deux utilitaires pour surveiller vos périphériques de stockage  et anticiper  les défaillances : smartctl et smartd. Ce dernier scanne l’ensemble des disques du système au démarrage et vous alerte dès qu’un certain seuil est atteint.

On pourra obtenir le diagnostic d’un disque via la commande :

~# smartctl -a /dev/sda

30

L’indicateur Pre-fail signifie que le disque peut potentiellement vous causer bientôt quelques soucis (apparemment, à ce niveau,moi ça va), alors soyez vigilant ! Notez que si le support de SMART n’est pas activé, on effectuera au préalable :

~# smartctl -s on /dev/sda 

31

05Cartes et périphériques USB :

Pour identifier les cartes et adaptateurs reliés au bus PCI (cartes son, cartes réseau, cartes graphiques…), on utilisera la commande lspci, avec l’option -v, -vv ou -vvv selon le niveau de détail souhaité. L’option -n retourne les identifiants numériques des différents périphériques ; vous pouvez alors spécifier un seul périphérique via l’option -d suivie de son identifiant.

Pour obtenir la liste et les caractéristiques de vos périphériques USB (clés, disques, claviers, souris, baladeurs, webcams, ect.), une seul commande à connaître : lsusb. Là encore, vous obtiendrez davantage d’informations avec l’option -v :

~$ lsusb -v

32.jpg

06 Les « couteaux suisses » :

Pour connaître votre machine sur le bout des doigts, retenez la commande lshw (hardware lister), qui permet de recueillir quantité d’informations sur l’ensemble de votre matériel (carte mère, mémoire, CPU, bus, contrôleur audio, paramètres réseau,ect.). Pour lire l’ensemble de ces données sur une page web, on utilisera l’option -html suivie d’un nom de fichier de destination :

~# lshw -html > mon_materiel.html

(ceci ne représente que 10% du résultat rendu sur le matériel de machine contenu dans la page HTML récolté en à peine 5 secondes. De ce fait, cette commande pourrait s’avérer être « excellente » au niveau de la sécurité d’un système en terme de récolte d’informations (hardware) sur la machine ciblée (« forensic »).


La commande dmidecode retourne elle aussi de nombreuses informations : elle permet de lire la table DMI (Desktop Management Interface) de l’ordinateur. Vous obtiendrez ainsi des informations sur l’état actuel de votre machine, mais aussi sur ses possibilités (quantité mémoire, vitesse maximale du processeur,ect.). On l’utilise habituellement avec l’option -s ou l’option -t suivies d’un mot-clé : je vous invite à consulter la page de manuel de dmidecode pour prendre connaissance des mots-clés disponibles.

34

Le répertoire /proc constitue lui aussi une vraie mine d’informations :

► le fichier /proc/cpuinfo (évoqué plus haut) : contient toutes les informations sur le ou les processeur(s) de la machine (modèle,famille,taille du cache,ect).

► le fichier /proc/devices : liste les différents périphériques classés par groupe (caractère et bloc).

► le fichier /proc/meminfo : donne de nombreuses informations sur la mémoire vive du système.

► le fichier /proc/modules : affiche une liste de tous les modules chargés dans le noyau.

► le fichier /proc/mounts : renferme une liste de tous les montages utilisés par le système.

► le fichier /proc/version : contient les informations sur la version du noyau en cours d’utilisation.

► le fichier /proc/uptime : renvoie le temps écoulé depuis le démarrage, ainsi que le temps passé à ne rien faire (en secondes).

04 ) Comment monter un système de fichiers ?

Pour accéder aux fichiers d’une partition, il est nécessaire que celle-ci soit « montée » sur votre système, autrement dit, l’arborescence de fichiers qui se trouve sur ladite partition doit être attachée à un répertoire du sytème de fichiers actif.

35

01Montage :

La plupart des périphériques de stockage amovibles, quels qu’ils soient, sont aujourd’hui montés automatiquement sur la plupart des distributions Linux ; vous le connectez et le périphérique est de suite accessible via votre gestionnaire de fichiers habituel. Il n’en est pas de même pour le systèmes de fichiers distants par exemple, où il est parfois nécessaire d’effectuer le « montage » manuellement ….

Le montage d’un système de fichiers se fait via la commande mount, selon la syntaxe suivante :

~# mount [-t type] [-o options[,…]] /chemin/vers/répertoire/à/monter /chemin/vers/point_de_montage

36

L’option -t est facultative ; si elle n’est pas mentionnée, le programme essayera de déterminer lui-même le type de système de fichiers concerné.

« le répertoire /mnt de votre système est historiquement dédié aux montages de systèmes de fichiers, son utilisation n’est cependant pas une obligation. »

Parmi les options de la commande mount, on retiendra :

defaults : elle englobe les options les plus utilisées, décrites ci-après : rw, suiddev, exec, auto, nouser et async.

auto/noauto : signifie que le système de fichiers peut être monté automatiquement (ou non).

dev/nodev : implique que les fichiers spéciaux de périphériques de type caractère ou bloc présents sur le système de fichiers seront interprétés (ou non).

exec/noexec : permet l’exécution (ou non) des fichiers binaires.

suid/nosuid : prend en compte (ou non) les bits « s » des fichiers.

user/nouser : signifie que n’importe quel utilisateur ou que seul root a le droit de monter le système de fichiers ; l’utilisation de user implique les options noexec, nosuid, nodev.

ro/rw : implique un montage en lecture seule ou en lecture/écriture du système de fichiers.

sync/async : active ou désactive les écritures synchrone. En général, on active l’écriture synchrone pour les systèmes de fichiers de supports amovibles.

Dans le cas d’une image ISO, qui est un système de fichiers au format , le montage pourra s’effectuer comme suit :

~# mount -t iso9660 -o loop image.iso /mnt/ISO

Constatez qu’on utilise ici l’image comme un périphérique ; elle est en fait rattachée à un périphérique loopback (qui permet de simuler un périphérique bloc). Comme on peut le voir dans la fiche dédiée à la gravure de CD/DVD, ceci permet entre autres de vérifier le contenu de l’image.

Pour visualiser l’ensemble des montages effectifs sur le système, on exécute la commande mount sans option, ni paramètre :

~$ mount

37

On peut visualiser sur chaque ligne le fichier de périphérique, le point de montage, le type de système de fichiers, ainsi que les options de montage. La commande mount retourne ici le contenu du fichier /etc/mtab (mounted file systems table).

02Démontage :

L’opération de démontage permet de synchroniser les données en mémoire avec celles réellement inscrites sur le périphérique. Le démontage s’effectue avec la commande umount, suivie au choix du fichier de périphérique ou bien du point de montage :

~# umount <périphérique>

ou :

~# umount

38

Le démontage d’un système de fichiers ne peut être effectué que si aucun autre processus n’y accède simultanément ; dans le cas contraire, le système vous répond que le démontage est impossible. Il faut alors vérifier par exemple qu’aucune application n’est en train de lire un fichier stocké sur le périphérique.

Pour prendre connaissance de tous les processus manipulant un fichier, vous pouvez utiliser la commande fuser ainsi :

~$ fuser -vm /dev/sda1

39

03Montages automatiques :

Il est possible de prédéfinir différents montages de systèmes de fichiers dans le fichier /etc/fstab de votre système ; les montages qui s’y trouvent seront effectués automatiquement au démarrage de la machine (du moins, tous ceux qui ne possèdent pas l’option noauto).

Le fichier fstab est généré automatiquement lorsque vous installez une distribution Linux ; on y trouve par défaut les différents points de montage que vous avez définis lors de l’installation, par exemple :

40

Vous pourrez ajouter les différents montages que vous utilisez régulièrement, à condition de bien respecter la syntaxe du fichier. Dans l’ordre, on trouve sur chaque ligne :

► le périphérique à monter ; il est préférable d’indiquer son label (voir ci dessous) ou son UUID (identifiant unique universel), comme ici, plutôt qu’un fichier de périphérique statique.

► le point de montage.

► le type du système de fichiers.

► les options de montage, séparées par des virgules.

► la fréquence de dump (pour les outils de dump ou de sauvegarde).

► la fréquence de vérification du système de fichiers par fsck ; la valeur 0 signifie que le système doit être ignoré, 1 signifie qu’il doit être vérifié en premier, 2 en deuxième, ect.

Comprenez que l’utilisation de ce fichier permet aussi de saisir des commandes mount « allégées » ; il suffira de saisir le point de montage (ou le nom du périphérique) pour monter le sytème de fichiers correspondant avec les options adéquates.

04Identifiez vos périphériques avec les labels :

Un label est un lien symbolique vers le fichier de périphérique correspondant ; pour visualiser les labels utilisés :

~$ ls -l /dev/disk/by-label/

41

L’utilisation de labels est intéressante, car les périphériques deviennent alors identifiables quel que soit leur emplacement. Sans label, si vous êtes amené à réorganiser les disques, il faut systématiquement penser à modifier le fichier /etc/fstab .

Lors du montage, on utilisera l’option -L suivie du label :

~# mount -L USBDISK

► Pour visualiser le label d’un système de fichiers de type ext2/3/4, on utilise la commande e2label (fournie par le paquet e2fsprogs) :

~# e2label <périphérique>

Pour modifier le label (16 caractères maximum, sinon il sera tronqué).

~# e2label <périphérique>

42

► Pour un système de fichiers de type btrfs (il devra être démonté au préalable) :

~# btrfs filesystem label <périphérique>

43

► Pour les systèmes de type vfat, on se tournera vers mlabel, fourni par le paquet mtools.
Pour afficher le label :

~# mlabel -si <périphérique> ::

Pour le modifier, après avoir démonté le système de fichiers, on saisira :

~# mlabel -i <périphérique> ::

44

05 ) Faire le ménage sur son disque .

À force de télécharger de la musique et des vidéos, de tester les toutes dernières versions de logiciels et distribution à la mode (comme moi), votre disque peut se retrouver très vite saturé et voilà que vous manquez d’espace pour des données essentielles ! Nous allons donc voir ici comment supprimer des fichiers devenus obsolètes ou inutiles afin de gagner un peu d’espace disque.

disque

01Le cache des paquets logiciels :

Les paquets téléchargés et installés sur le système sont stockés « en cache » dans le répertoire /var/cache/apt/archives/ sur une distribution type Debian/Ubuntu. Pour vider le cache, on lancera :

~# aptitude clean

ou :

~# aptitude autoclean

45
Avec autoclean, on ne supprime que les paquets qui ne sont plus proposés au téléchargement et on visualise la liste des paquets supprimés, ainsi que la quantité d’espace libéré.

46

02Les résidus de configuration :

Sur un système de type Debian, pour lister les paquets non installés dont il reste des éléments de configuration sur le système, on pourra faire appel à la commande dpkg :

~$ dpkg -l | grep ^rc

47

Ensuite, pour supprimer ces éléments de configuration « résiduels », on pourra utiliser la commande suivante :

~$ dpkg -l | grep ^rc | awk {print$2} | xargs sudo dpkg -P

48

On récupère ici la liste des paquets retournés par la première commande (qui se trouvent dans la deuxième colonne), puis on purge ce paquets à l’aide de l’option -P.

03Les fichiers de langues inutilisés :

localpurge est un utilitaire pour distribution type Debian/Ubuntu, qui permet de supprimer tous les fichiers de localisation ou paramètres régionaux dont vous n’avez pas l’utilité. À l’installation, il vous est demandé de sélectionner (à l’aide de la touche [espace] les locales qui vous intéressent : on conservera bien entendu [fr], mais aussi [en], car tous les fichier ne sont peut être pas traduits en français …

49

Votre séléction se retrouve ensuite dans le fichier /etc/locale.nopurge. Ceci fait, on lance simplement la commande localepurge (sous root) ; si le programme a été configuré comme tel, il retourne l’espace disque libéré (option SHOWFREEDSPACE du fichier de configuration).

« Attention, la seule manière de réinstaller les locales est de réinstaller complètement les paquets Debian correspondants !« 

Pour redéfinir ultérieurement les locales à conserver (si vous changer d’avis..), vous pourrez lancer la commande :

~# dpkg -reconfigure localepurge

50

04Le cache et les logs de vos applications WEB :

Votre navigateur web utilise un cache pour stocker les pages récemment consultées, pour minimiser le temps de chargement si vous y revenez ultérieurement. Ce cache se trouve généralement dans votre répertoire personnel, dans le répertoire de configuration de l’application (~/.mozilla/firefox/xxxxxxxx.default/Cache/ pour Firefox/Iceweasel.). Un rm * dans ce répertoir et le tour est joué !

~# rm * ~/.mozilla/firefox/xxxxxxxx.default/Cache/

De même, le client de messagerie Thunderbird/Icedove, utilise un cache correspondant au répertoire à ~/.thunderbird/xxxxxxxx.default/Cache.

Retenez par ailleurs que bon nombre de clients de messagerie instantanéee stockent par défaut l’ensemble de vos conversations (dans un répertoire ou un fichier « log(s)« . Des services de synchronisation en ligne, tel que Ubuntu One, conservent également des traces des différentes opérations effectuées (dans .cache/ubuntuone/log/ par exemple).

[ASTUCE]

FICHIERS DE SAUVEGARDE :

Il peut également être intéressant de supprimer les éventuels fichiers de sauvegardes automatique, identifiables par le caractère ~ en fin de nom. Pour rechercher ces fichiers, on utilise la commande find :

~$ find ~/ -name ‘*~’

51

Après avoir vérifié la liste des fichiers retournés par la commande, vous pouvez lancer la suppression de l’ensemble via la commande :

~$ rm -i `find ~/ -name ‘*~’`

L’option -i, falcultative, permet de demander confirmation pour la suppression de chacun des fichiers.

06 ) Gérer les services disponibles :

Identifier les services qui sont lancés au démarrage de votre système, repérer parmi eux les services inutiles pour votre propre usage, savoir les contrôler (les arrêter ou les stopper momentanément), voilà les quelques opérations qui sont abordées ici.

52

01 Mais qu’est-ce qu’un service ?

Au démarrage de votre système, de nombreux programmes sont lancés de façon transparente, « en arrière plan », pour vous permettre d’effectuer les tâches habituelles (lancer des applications graphiques, écouter de la musique, accéder à vos différents répertoires, imprimer des documents, naviguer sur le Web,ect.). Ces programmes sont appelés « services » ou encore « démons » ou « daemons« . Chaque distribution fait le choix des services à lancer par défaut dès le démarrage du système.

On distingue plusieurs systèmes de gestion de services au sein des distributions GNU/Linux : System V (le plus ancien, qui tend à disparaître pour être remplacé par l’un des deux suivants), Upstart (intégré à Ubuntu depuis sa version 6.10), et Systemd, le plus récent (intégré à Fedora depuis sa version 15).

Les deux premiers fonctionnent selon des niveaux d’exécution (ou runlevels), Systemd, en revanche, fonctionne sur la base de « cibles » (ou targets). À chaque niveau d’exécution ou cible correspond un mode de fonctionnement du système, dans lequel certains services sont actifs et d’autres non. Et chaque distribution possède un niveau d’exécution ou une cible par défaut. Pour Debian et Ubuntu, il s’agit du niveau 2 ; chez Fedora, il s’agit de la cible graphical.target.

53

02 –  Gérer les services sur une distribution basée sur System V (ex.Debian) :

Après le processus de démarrage, le tout premier programme lancé, init, exécute tous les scripts de démarrage du  niveau d’exécution par défaut (le niveau 2 dans le cas Debian), situés dans /etc/rc2.d/ : on y trouve les liens pointant vers les scripts des différents services du services du système regroupés dans /etc/init.d/.

Un travail est en cours pour convertir la séquence d’amorçage de Debian, qui permettra à terme au système de démarrer bien plus vite. C’est pourquoi il est possible d’utiliser actuellement plusieurs outils pour gérer les services …

Pour commencer, la commande service permet d’agir sur les scripts de type System V contenus dans /etc/init.d/. Pour obtenir la liste des services disponibles sur le système, on tape :

~# service –status-all

54

Le [+] signifie que le service tourne ; le [-] signifie que le service n’est pas lancé ; et le [?] que l’état du service ne peut être déterminé ainsi ; on utilisera dans ce cas :

~# /etc/init.d/mysql status

55

Cette commande permet d’obtenir l’état courant d’un service particulier, que l’on peut visualiser également avec :

~# service apache2 status

56

Pour gérer les services, on utilisera la commande :

~# service <nom_du_service>
start | stop | restart |reload

ou bien :

~# /etc/init.d/ <nom_du_service>
start | stop | restart | reload

57

On démarre (start), arrête (stop), redémarre (restart) le service, ou lui demande de relire sa configuration (reload / force-reload).

À présent, voyons comment modifier la liste des services lancés au démarrage du système. Pour ajouter un service (ici le serveur web Apache) à cette liste :

~# update-rc.d apache2 defaults

Quand  l’option defaults est utilisée, update-rc.d crée des liens pour démarrer le service dans les niveaux d’exécution 2,3,4 et 5 et des liens pour arrêter le service dans les niveaux 0,1 et 6.

Depuis Debian 6.0 (Squeeze), on peut utiliser également la commande insserv :

~# insserv apache2

58

qui prend en paramètre – tout comme les commandes évoquées plus haut – un script exécutable se trouvant dans /etc/init.d/. La commande ne retourne rien si tout se déroule correctement.

Pour faire en sorte qu’un service ne soit plus lancé au démarrage, on utilise l’option -f qui va supprimer tous les liens associés au service en question :

~# update-rc.d -f bluetooth remove

Ou alors :

~# insserv -r bluetooth

Le service bluetooth est alors ôté de tous les niveaux de démarrage ; il ne sera pas démarré au prochain démarrage du système.

Et pour terminer cette partie sur le système, je vous conseil de jeter un oeil de connaître la commande systemd-analyze blame (issue du paquet éponyme) qui liste le temps de démarrage des différents services :

~# systemd-analyze time 

59

~# systemd-analyze blame 

60

Voilà que s’achève la partie « système » du chapitre « ligne de commandes« . La prochaine partie concernera le « Multimédia« .

À bientôt …….

logo_gnu_linux_pratiqueLinuxfrench

[5.1] Ligne de commandes – Cinquième et dernière partie ! Un peu de tout ….[FICHIERS]

Bonjour à tous et bienvenus pour cette « dernière » partie consacrée à la ligne de commande.

Celle-ci sera accès sur un panel de commandes utiles pour une meilleur gestion de votre système via votre terminal.

À commencer par :

Fichiers :
Comment retrouver rapidement un fichier ? Comment renommer des fichiers par lots ? Comment effacer ses données de façon sécurisée ? Comment manipuler les archives de fichiers ? Comment synchroniser ses données ? Comment manipuler des fichiers PDF ? …

Système :
Comment gérer les utilisateurs du système et leurs droits ? Comment gérer ses paquets logiciels ? Comment faire le ménage sur son disque dur ? Comment gérer les différents services du système ? Comment identifier précisément son matériel et ses capacités ? …

Multimédia:
Comment graver un CD/DVD ? Comment retoucher un lot de photos en un tour de main ? Comment enregistrer son bureau pour publier un tutoriel en ligne ? Comment récupérer des vidéos sur les sites de contenus dédiés ?

Réseau :
Comment identifier et gérer ses interfaces réseaux ? Comment mettre en place une connexion SSH ? Comment visualiser un bureau à distance ? Comment partager ses fichier entre un ordinateur Linux et un autre sous Windows ? Comment automatiser la sauvegarde de ses données ?

shellshock1

01 Fichiers.

01 ) Retrouver rapidement un fichier égaré.

Mais si, cela peut arriver bien plus souvent que vous ne le pensez ! Vous créez un document, vous l’enregistrez rapidement sans vraiment regarder où … et impossible de remettre la main dessus ! Ou alors, vous souhaitez éditer le fichier de configuration d’une application, mais vous n’avez aucune idée de l’endroit où il peut être stocké. Ces quelques commandes vont vous aider à retrouver très vite ce que vous cherchez.

01Vous connaissez son nom ?

La commande locate permet de localiser instantanément n’importe quel fichier de votre disque, y compris les fichiers cachés. Pour cela, elle s’appuie sur une base de données contenant la liste de tous les fichiers et de tous les répertoires de votre disque (/var/lib/mlocate/mlocate.db).

1

Pour retrouver un fichier, on indique son nom ou une partie de son nom :

~$ locate profil
/etc/profile
/etc/profile.d
…………………..

2 - locate

Il est nécessaire de mettre régulièrement à jour la base de données utilisée par locate via la commande :

~# updatedb

On pourra penser à configurer  une mise à jour automatique de la base via cron ou anacron.

La commande find parcourt toute l’arborescence du répertoire fourni en paramètre et y recherche le fichier spécifié :

~$ find /home/user/documents -name « monFichier.txt« 

3 - find

Il est possible d’utiliser des expressions régulières pour spécifier le nom du fichier recherché. Attention, il s’agit ici d’une recherche « exacte« : une recherche du motif « monFic » ne renverra pas « monfichier.txt« .

02Vous connaissez une partie du contenu :

La commande grep (une commande que je conseil vivement de connaitre et de maitriser le plus possible) utilise les expressions régulières pour effectuer ses recherches. Elle permet de rechercher une chaîne de caractères dans des fichiers, mais elle est bien souvent utilisée pour filtrer le résultat d’autres commandes en fonction d’un motif particulier.

grep prend en paramètre la chaîne de caractères à rechercher, suivie du nom de fichier dans lequel effectuer la recherche. Par exemple, pour rechercher toutes les lignes du fichier monFichier.txt dont la première lettre est une majuscule :

~$ grep « ^[A-Z] » monFichier.txt

4 - grep

La commande grep retourne alors les lignes correspondant à la recherche demandée. Il est toutefois possible de modifier ce comportement à l’aide d’options :

-c : retourne le nombre de lignes correspondant à la recherche.

–color : affiche le motif recherché (ici le « M » majuscule) en couleur.

4.1 - grep

-n : retourne les lignes correspondant à la recherche, préfixées par leur numéro.

-f : permet de passer en paramètre un fichier contenant une liste de motifs à rechercher. Par exemple :
~$ grep -f liste monFichier.txt

-i : ignore la case dans le motif de recherche et dans le fichier.

Pour lancer la recherche sur l’ensemble des fichiers du répertoire courant, on utilisera le caractère * :

~$ grep « ^[A-Z] » *

4.2 - grep

Pour parcourir toute l’arborescence de façon récursive, on utilise aux choix l’option -r ou la commande rgrep :

~$ grep -r « ^[A-Z] » *
~$ rgrep « ^[A-Z] » *

4.3 - rgrep

03Vous avez d’autres critères de recherche ?

La commande find permet d’effectuer la recherche sur bien plus de critères que le simple nom de fichier. Par exemple, vous pouvez rechercher tous les fichiers dont la taille est supérieur à 5Mio et qui ont été modifiés il y a moins de 12 jours grâce aux options -size et -ctime :

~$ find / -size 5M -ctime 12

5 - find

Notez qu’à chaque fois qu’un fichier correspond à la recherche, il est possible d’exécuter une commande sur celui-ci avec l’option -exec ou -ok.
Imaginons que vous vouliez rechercher puis supprimer toutes les images ISO de votre répertoire personnel. Il suffit d’exécuter :

~$ find . -name « *.iso » -exec rm {} \;

La commande à exécuter (ici rm) suit directement l’option -exec ; les accolades seront remplacées par les noms de fichiers correspondant à la recherche. Le caractère ; indique que la séparation entre les commandes rm se fera à l’aide du point-virgule (notez la présence de l’anti-slash qui permet d’échapper ce caractère). L’option -ok se comporte comme -exec mais vous demande confirmation avant d’exécuter une action.

04Vous recherchez un fichier particulier ?

whereis permet de retrouver des fichiers correspondant à des commandes système (fichiers binaires, sources et pages de manuel). Par défaut, elle affiche tous les fichiers associés à une commande, comme dans cet exemple avec la commande yum :

~$ whereis yum
yum : ………………………...

6 - whereis

Pour restreindre l’affichage à certains types de fichiers, on utilise les options suivantes : –b : pour les fichiers binaires
-s : pour les sources
-m : pour les pages manuel

05Vous recherchez le nom d’un paquet logiciel ?

Lorsqu’on compile une application, il est fréquent d’obtenir un message d’erreur indiquant qu’un fichier d’une librairie est manquant… et il est toujours très pénible de rechercher le nom de la librairie à installer.

Les utilisateurs d’une distribution Debian, Ubuntu ou dérivée pourront utiliser la commande apt-file (à installer au préalable), qui fonctionne à partir d’une base de données que vous mettrez à jour en tapant :

~$ sudo apt-file update

Ensuite, vous n’aurez plus qu’à saisir la commande apt-filesearch, suivie du nom du fichier, comme dans cet exemple :

~$ apt-file search libfftw3.so.3

Le nom du paquet correspondant apparaît en début de ligne ; vous pouvez également visualiser le chemin d’installation.

Les utilisateurs de Fedora quant à eux pourront trouver le nom du paquet auquel appartient un fichier via la commande :

~$ yum provides libfftw3.so.3

La commande dpkg avec l’option -S permet également de savoir à quel paquet appartient un fichier, mais cette fois, la recherche ne concerne que les paquets déjà installés sur votre disque :

~$ dpkg -S libfftw3.so.3

7

02 ) Renommez proprement vos fichiers.

L’utilitaire detox, présent dans les dépôts logiciels de la plupart des distributions Linux, permet de « nettoyer » et convertir rapidement les noms de fichiers comportant des espaces et des caractères spéciaux, de façon à garantir leur interopérabilité.

detox est également capable de traduire les caractères Latin (ISO 8859-1), les caractères Unicode encodés en UTF-8 et les caractères échappés des chaînes CGI.

01Éditer les filtres :

Pour effectuer le « nettoyage », detox utilise plusieurs filtres, dont l’ensemble constitue une « séquence » et qui seront appliqués au fichier passé en paramètre.

Les différentes séquences disponibles sont définies dans le fichier /etc/detoxrc du système, qui sera applicable à l’ensemble des utilisateurs ; il est bien sûr possible de créer votre propre fichier de configuration, ~/.detoxrc, qui peut venir compléter le fichier principal.

On trouve dans ce fichier des séquences comme celles-ci :

~$ cat /etc/detoxrc

8 - detoxrc

On trouve également une liste de fichiers à ignorer :

8.1

La séquence nommé default est celle qui sera exécutée si vous ne spécifiez rien ; l’option -s suivie d’un nom de séquence permet d’activer les filtres correspondants.

02Exemple de renommage :

Nous allons utiliser ici la séquence defautl pour supprimer les espaces (l’option -v permet d’activer le mode « verbeux » = « voir ce qui se passe pendant…« ) :

~$ detox -v Ce\ Nom\ Comporte\ Des\ Espaces.txt

8.2.1
8.2

Puis on supprime les majuscules, avec la séquence lower :

~$ detox -s lower Ce_Nom_Comporte_Des_Espaces.txt

8.3

8.3.1

Les séquences disponibles, ainsi que les fichiers ignorés, peuvent être listés via l’option -L ; avec l’option -v, vous visualiserez les filtres qui sont utilisés dans chaque cas :

~$ detox -vL

8.4

Très utile également : l’option -n, qui permet de simuler la commande pour observer le résultat que l’on obtiendrait et l’option -r, qui active la récursivité de la commande (elle sera donc appliquée à l’ensemble des fichiers et répertoires contenus dans le répertoire passé en argument).

03 Les filtres disponibles :

Comme nous l’avons vu, dans chaque séquence sont utilisés un ou plusieurs filtre(s) parmi : safe, wipeup, lower, uncgi, utf_8, ect. La page de manuel de detoxrc nous renseigne quant à leur rôle spécifique. Ainsi, le filtre iso8859_1 traduit les caractères Latin-1 en leurs équivalents ASCII. De même, le filtre utf_8 traduit les caractères Unicode encodés en UTF-8 et le filtre uncgi traduit les caractères CGI échappés dans leurs équivalents ASCII.

Le filtre wipeup permet de s’affranchir de caractères superflus, comme un tiret double ou un underscore double, ou bien une succession de tirets et d’underscores (_-_). Tout cela sera traduit en un seul et unique tiret ou underscore.

Le filtre safe traduit les caractères susceptibles de poser un problème d’interprétation sous Unix : les caractères ` ! @ $ * \ | : ; ‘ ? / sont ainsi traduits en _ et les caractères ( ) [ ] { } traduits en .

À savoir que ces deux dernier filtres, wipeup et safe, doivent toujours être exécutés après un filtre de traduction (iso8859_1, utf_8, uncgi), afin de s’affranchir du risque d’introduire un caractère illégal dans le nom final du fichier.

Le filtre lower, vu plus haut, permet de transformer toutes les lettres majuscules en minuscules.

Le filtre max_length permet quant à lui de limiter le nombre de caractères du nom du fichier. Bien entendu, ce filtre agit en prenant soin de conserver l’extension du fichier. On pourra l’appliquer comme suit :

8.5

Ce qui donne comme résultat :

~$ detox ce_nom_est_beaucoup_trop_long.txt

8.6

03 ) Échanger plusieurs fichiers simplement en créant une archive.

Dans un souci d’économie d’espace disque ou bien pour transférer de nombreux fichier en une seule opération et en conservant l’arborescence initiale, la création d’une archive – compressé de surcroît – s’avère particulièrement utile…

01Créer une archive de fichiers :

~$ tar -cvf répertoire_à_archiver

9

Tar est le système d’archivage le plus couramment utilisé sous Linux. L’option -c (create) indique que nous créons une archive, l’option -v (verbose) active le mode verbeux (seront listés à l’écran l’ensemble des répertoires et fichiers placés dans l’archive) et l’option -f (file) introduit le nom de l’archive crée.

~$ tar -rvf mon_archive.tar répertoire_2 fichier.txt

9.1

On peut ajouter de nouveaux éléments a posteriori dans une archive existante, grâce à l’option -r et en spécifiant le ou les nouveau(x) fichier(s)/répertoire(s) à ajouter.

~$ tar -Af mon_archive.tar une_autre_archive.tar

Il est également possible d’ajouter un fichier .tar à une archive déjà crée, avec l’option -A. Ici, les fichiers contenus dans une_autre_archive.tar seront concaténés à ceux de mon_archive.tar.

~$ tar -uvf mon_archive.tar répertoire_à_archiver

L’option -u (update) permet d’ajouter uniquement les fichiers qui ont été modifiés depuis la création de l’archive. Ici, on recherche dans répertoire_à_archiver les mises à jour éventuelles, qui remplaceront alors leur ancienne version dans l’archive ; les fichiers qui n’étaient pas déjà présents dans l’archive sont eux aussi ajoutés.

(pensez à toujours créer un répertoire qui contiendra l’ensemble des fichiers et sous-répertoires de votre archive. Ainsi, lors de l’extraction, tous les fichiers seront placés dans un unique répertoire, ce qui sera beaucoup plus propre et plus pratique ! )

02Compresser une archive :

~$ tar -czvf mon_archive.tgz répertoire_à_archiver
~$ tar -cjvf mon_archive.tgz répertoire_à_archiver

Pour compresser l’archive à créer, on ajoute simplement l’option -z ou -j, selon si l’on utilise l’outil de compression gzip ou bzip2 respectivement (tous deux pré-installés sur la plupart des distributions)

(le format bzip2 est un format de compression historiquement très utilisé sous Unix, car son taux de compression est meilleur que celui de gzip (mais la compression et le décompression sont plus lentes). Toutefois, bzip2 ne compresse que les fichiers (pas les répertoires).

03Lire le contenu d’une archive :

~$ tar -tf archive.tar
~$ tar -tzvf archive.tar.gz
~$ tar -tjvf archive.tar.bz2

On utilise l’option -t, éventuellement accompagnée de l’option -z dans le cas d’une archive compressée avec bzip2. L’option -v (mode verbose) permet de visualiser à l’écran les permissions sur chacun des éléments de l’archive.

04Extraire le contenu d’une archive :

~$ tar -xf archive.tar
~$ tar -xzvf archive.tar.gz
~$ tar -xjvf archive.tar.bz2
~$ tar -xkf archive.tar

C’est l’option -x (eXtract) qui permet d’extraire le contenu d’une archive ; encore une fois, on l’accompagne si besoin de l’option -z ou -j selon l’algorithme de compression utilisé. Une autre option qui peut s’avérer utile est l’option -k (–keep-old-files) qui permet de préciser que l’on souhaite pas remplacer les fichiers existants lors de l’extraction.

05Cas du format ZIP :

~$ zip -rv mon_archive.zip répertoire_à_archiver

Il est également possible de créer une archive compressée à l’aide de la commande zip. L’option -r (recursive) implique une descente récursive dans les répertoires, l’option -v (facultative) permet comme à l’habitude de visualiser la liste des fichiers intégrés dans l’archive.

~$ zip -rvu mon_archive.zip répertoire_à_archiver

Pour ajouter des fichiers ou mettre des fichiers de l’archive, on utilise l’option -u ; on recherche ici les nouveaux fichiers et les fichiers qui ont été modifiés dans répertoire_à_archiver

~$ unzip archive.zip

La commande unzip permet de décompresser et d’extraire les fichiers contenus dans une archive .zip. À noter que l’option -e (encrypt) permet de protéger votre archive par un mot de passe lors de la création. Pour décompresser une telle archive, vous devrez bien sûr être en possession de ce mot de passe …

10 - unzip

06Cas du format 7z :

L’outil p7zip supporte de très nombreux formats d’archive et de compression ; selon les distributions, vous le trouverez dans les dépôts logiciels sous le nom p7zip, p7zip-full et p7zip-rar. Les deux premiers paquetages se différencient par le nombre de formats pris en charge et le dernier ajoute le support du format rar.

~$ 7z mon_archive répertoire_à_archiver

Pour créer une nouvelle archive, on utilise l’option a (add) suivie du nom de l’archive (l’extension .7z est ajoutée automatiquement), et des noms de fichiers/répertoires à y inclure ; la récursivité est implicite. Pour protéger l’archive par un mot de passe, on ajoute l’option -p suivie du mot de passe (qui sera demandé pour l’extraction).

~$ 7z u mon_archive.7z répertoire_à_archiver nouveau_répertoire/fichier

L’option u (update) permet d’ajouter de nouveaux fichiers et d’enregistrer les modifications effectuées sur les fichiers déjà présents dans l’archive .

~$ 7z l mon_archive.7z

L’option l (list) permet de lister le contenu de l’archive.

~$ 7z x mon_archive.7z

L’extraction des fichiers s’effectue via l’option x (extract).

07Cas du format RAR :

~$ unrar x une_archive.rar

Pour extraire le contenu d’archives .rar, on utilise la commande unrar (issue du paquet éponyme). L’extraction s’effectue via l’option x ; on listera le contenu de l’archive avec l’option l .

11 - archivze

04 ) Récupérez vos fichiers effacés !

Vous avez effacé par mégarde les photos de la carte mémoire de votre appareil ou bien formaté une partition qui contenait des données très importantes ? Inutile de pleurer toutes les larmes de votre corps, cela ne fera pas ré-apparaître vos fichiers ! PhotoRec en revanche, lui, le pourra.

12 - photorec
PhotoRec est un programme conçu à l’origine pour récupérer les photos effacées des cartes mémoire d’appareil photos (d’où son nom, de l’anglais, Photo Recovery). Aujourd’hui, il est capable de récupérer plus d »une centaine de formats de fichiers différents (images,vidéos,archives,documents…). Il fonctionne avec des disques durs, CD ROM, CompactFlash, Memory Stick, SecureDigital, SmartMedia, MicroDrive, MMC, USB Memory Drives…

PhotoRec se trouve dans les dépôts de la plupart des distributions, vous pourrez donc l’installer très facilement via votre gestionnaire de paquets habituel. On le lance tout simplement via la commande (en tant que root) :

~# photorec

13

Les options :

Paranoid : activée par défaut, permet de vérifier les fichiers récupérés ; les fichiers invalides sont rejetés. Pour récupérer davantage de JPEG fragmentés, vous pouvez activer le Brute force (qui est beaucoup plus gourmand en ressources processeur).

Allow partial last cylinder : désactivée par défaut, modifie la façon dont la géométrie du disque est déterminée (cela n’affecte que les volumes non partitionnés).

Keep corrupted files : désactivée par défaut, elle conserve les fichiers récupérés même s’ils sont endommagés.

Expert mode : désactivée par défaut, permet de forcer la taille de bloc utilise et l’offset. Sur un disque entier ou une partition reformatée, si PhotoRec retrouve peu de fichiers, vous pouvez essayer la valeur minimale que PhotoRec propose (il s’agit de la taille d’un secteur, 0 sera alors utilisé pour l’offset).

Low memory : désactivée par défaut, vient pallier le manque de mémoire éventuel de votre système (à n’utiliser qu’en cas de systèmes de fichiers très volumineux et très fragmentés).

14

01Choix du média :

Le programme commence par vous demander de séléctionner le média concerné ; vous effectuez la sélection à l’aide des touches fléchées, puis validez votre choix avec la touche [Entrée]. On choisi la carte mémoire de notre appareil, identifiée ici par /dev/sda .

02Choix de la partition :

PhotoRec dresse ensuite la liste des partitions sur le média ; choisissez celle que vous souhaitez, ou bien lancez le programme sur l’ensemble du disque (1er choix de la liste).

1516

Remarquez au bas de l’écran l’item [File Opt] : il mène à une liste de formats de fichiers. En effet, il est possible d’affiner la recherche en ne sélectionnant qu’un ou quelques format(s) de fichiers. La sélection s’effectue à l’aide de la barre d’espace. De même, l’item [Options] permet d’accéder aux diverses options du programme et éventuellement de les modifier. Retournez sur [Search], pour passer à l’étape suivante.

File options
17

Options
18

Search
19

03Système de fichiers :

Vous devez ensuite indiquer à PhotoRec dans quel type de système de fichiers se trouvent les fichiers effacés. Les systèmes de fichiers ext2 à ext4 sont traités de manière spécifique, d’où la nécessité du choix par l’utilisateur.

04Étendue de la recherche :

L’étape suivante vous invite à choisir si la recherche doit être effectuée sur toute la partition (Whole) ou bien seulement sur l’espace non alloué (Free).

20

05Stockage des fichiers :

Vous devez ensuite indiquer où PhotoRec doit stocker les fichiers retrouvés. Typiquement, on créera à cet effet un répertoire nommé « sauvegarde » ou « backup » à l’endroit de son choix. Attention : évitez de choisir ici un emplacement sur le disque qui fait justement l’objet de la recherche ! Naviguez dans l’arborescence de fichiers à l’aide des touches fléchées, puis tapez [C] lorsque votre choix est fait.

21

06Progression :

Et PhotoRec s’exécute ! Vous pouvez visualiser le temps restant estimé pour scanner le disque. Les fichiers retrouvés sont listés au fur et à mesure, classés par format, et sont stockés dans le répertoire que vous avez indiqué plus haut. Il vous suffira de le parcourir pour retrouver vos précieuses données. Notez que les noms de fichiers, eux, ne sont pas récupérés, mais avouez que c’est un moindre mal …

22

05 ) Effacer vos données de façon définitive et sécurisée.

Vous devez changer de poste de travail, ou vous séparer d’un disque dur ? Immédiatement vous pensez à toutes ces données personnelles et/ou sensibles qui traînent encore sûrement sur vos supports de stockage. Vous trouverez ici plusieurs méthodes permettant d’effacer complétement vos données sans laisser la moindre trace…

01Pourquoi faire plus compliqué que [Suppr] ?

Lorsqu’on supprime un fichier, qu’on vide la corbeille, ou qu’on formate une partition, le système signale dans la table d’allocation des fichiers que les clusters qui étaient jusque-là occupés sont désormais disponibles…Et c’est tout ! Les données, elles ne sont pas physiquement effacées. Par analogie, c’est comme si l’on supprimait un chapitre dans le sommaire d’un ouvrage, sans retirer le chapitre lui-même. Ainsi, ces données peuvent potentiellement être récupérées avec des outils appropriés…

De ce fait, le seul moyen de supprimer (pour de vrai) des données consiste à ré-écrire sur les secteurs à effacer ; on parle d’effacement « par sur-charge ».

Pourquoi une telle persistance des données ? Un disque dur est constitué d’aimants et ces derniers peuvent en quelque sorte « mémoriser » l’état antérieur du disque (du moins, une partie). On appelle cela le phénomène de rémanence. Ainsi, même si vous remplissez votre disque de zéros, il existe des techniques et outils (par exemple PhotoRec, présenté plus haut) pour accéder aux données retenues par les aimants. Ces traces résiduelles sont dues au fait que la tête d’écriture du disque n’est pas toujours parfaitement alignée sur sa piste ; elle écrit donc souvent un peu à gauche et à droite de la piste.

02Effacer un disque :

Avant de se lancer dans l’effacement d’un disque, on commence par identifier correctement le disque en question :

~# fdisk -l

24

La commande dd :
25 - dd

Issue du paquet coreutils, la commande dd (device to device) permet de copier bloc par bloc un fichier de périphérique vers un autre fichier de périphérique ou quelconque.

Pour effacer tout le disque en réinitialisant toutes les données à 0 :

~# dd if=/dev/zero of=/dev/sda

Pour effacer tout le disque en écrasant les données existantes avec les données aléatoires :

~# dd if=/dev/urandom of=/dev/sda

L’option if introduit le fichier à copier (ici /dev/zero ou /dev/urandom) et of indique le fichier résultant de la copie.

On pourra réduire le temps de chaque passe à l’aide de l’option bs, qui permet de spécifier le nombre d’octets (512 par défaut) écrits en une seule fois (par exemple, bs=1024).

Toutefois, l’utilisation de dd ne garantit pas à 100% l’effacement des données sensibles, comme nous l’avons expliqué en introduction.

La commande shred :

26 - shred

L’utilisation de la commande shred permet de contrer l’effet de rémanence ; elle consiste à écrire plusieurs fois un motif différent sur le même fichier. On pourra l’utiliser pour un fichier régulier, comme pour un fichier de périphérique.

~# shred -vfz -n 3 /dev/sda
shred: /dev/sda : passe 1/4 (random) …
shred: /dev/sda : passe 1/4
………………………………
……………………………………..

L’option -v permet, comme d’habitude, d’activer le mode verbeux. L’option -f permet de « forcer » l’opération, autrement dit, elle autorise shred à modifier les permissions du fichier si nécessaire. L’option -z écrit des zéros lors d’une dernière passe pour camoufler le déchiquetage du fichier. L’option -n introduit le nombre de passes (3 par défaut).

Attention : comme le souligne la page du manuel du programme (man shred), le déchiquetage considère que le système de fichiers écrasera les données sur place. Or, plusieurs structures de systèmes de fichiers ne remplissent pas cette condition. Ainsi, shred ne fonctionne pas (ou pas dans tous les modes) sur les systèmes suivants :

► les systèmes de fichiers journalisés ou à structure de journalisation (JFS, ReiserFS, XFS, ext3, ect).

► les systèmes de fichiers avec écriture redondante et continuant à écrire même en cas d’erreur (RAID).

► les systèmes de fichiers qui effectuent des instantanés (serveur NFS de Network Appliance).

► les systèmes de fichiers qui mettent en cache dans des dossiers temporaires (clients NFS version 3).

► les systèmes de fichiers compréssés.

On apprend ainsi que dans le cas du système ext3, très couramment utilisé sous Linux, shred sera d’une efficacité limitée dans le mode data=journal (mode dans lequel les données sont inscrites dans le journal avant d’être écrites dans le système de fichiers principal) ; en revanche, shred fonctionnera tout à fait normalement dans les modes data=ordered (le mode par défaut, dans lequel les données sont envoyées au système de fichiers avant l’écriture des métadonnées dans le journal) et data=writeback.

À savoir que le mode de journalisation d’un système ext3 peut être contrôlé en ajoutant l’option data= aux options de montage de l’arborescence dans le fichier /etc/fstab.

03Effacer un fichier sensible avec wipe :

27 - wipe

Pour effacer des fichiers réguliers de façon sécurisée, on pourra se tourner vers d’autres outils plus adaptés, wipe est l’un d’entre deux et se trouve dans les dépôts de la plupart des distributions ; on l’utilisera comme suit :

~$ wipe -r -i -q rep_à_effacer/

27 - wipe 2

L’option -r supprime l’ensemble du répertoire de façon récursive ; -i active le mode verbeux ; l’option -q permet de spécifier le nombre de passes (4 par défaut). L’option -c permet de modifier le spermissions sur les fichiers qui le nécessitent.

06 ) Synchronisez le contenu de vos fichiers ! 

Vous avez pour habitude de rapporter du travail à la maison ? Vous multipliez ainsi les versions de fichiers sans plus vous y retrouver ? Il est temps de vous organiser et d’opter pour la synchronisation de vos données …..

Unison

Le programme Unison permet de répliquer un ensemble de fichiers et/ou répertoires sur différentes machines ou différents disques de la même machine.
Compatible Unix et Windows, il permet de réaliser une synchronisation de fichiers entre ces deux types de système. Unison peut en outre être utilis pour les synchronisations à distance, via le protocole SSH.

Unison devra être installé sur chaque machine à synchroniser ; il est packagé pour la plupart des distributions. Nous distinguerons ici deux cas typiques : une synchronisation locale de deux répertoires et une synchronisation à distance.

28 - unison

01Synchronisation locale :

Imaginons que vous rentriez du travail avec votre clé USB contenant le dossier sur lequel vous avez travaillé toute la journée ; vous souhaitez synchroniser son contenu avec celui du dossier stocké sur votre ordinateur personnel, à la maison. Voici la commande à exécuter :

~$ unison -ui text /media/usbkey/rep1 /home/user/rep2 
Contacting server ……
……………………………
………………………………….

L’option -ui text utilisée ici nous permet de forcer l’utilisation en ligne de commandes d’Unison, sinon l’interface graphique se lance automatiquement (ce comportement dépend toutefois du binaire utilisé par votre distribution et vous ne serez peut être pas obligé d’utiliser cette option pour archiver le mode console).

La commande ne retourne rien pour l’instant étant donné qu’il s’agit de la première synchronisation de nos deux répertoires ; aucun changement n’est à noter.

À présent nous allons ajouter un nouveau fichier dans chacun des répertoires, puis lancer la synchronisation de ces derniers :

~$ unison -ui text /media/usbkey/rep1 /home/user/rep2
Contacting server…..
……………………………
…………………………………

Le programme liste les modifications une à une en vous demandant à chaque fois de préciser l’action à réaliser. Pour ce faire :

► la touche [f] pour follow, permet de valider la suggestion formulée par Unison (dans l’exemple ci-dessus, on valide la copie du fichier nommé file1 dans rep2) .

► les touches [<] et [>] permettent de modifier le sens de propagation.

► la touche [/] permet d’ignorer la modification et de ne rien faire.

La liste des modifications continue ainsi, jusqu’à l’exécution des actions en attente pour laquelle une confirmation vous est demandée :

Proceed with propagating updates? [] 

Plusieurs réponses sont possibles ici :

[y] ou [g] pour valider vos choix.

[n] pour revenir aux sélections.

[q] pour quitter le programme sans propager les modifications.

Si un même fichier se trouve dans chacun des répertoires, mais sous une version différente, Unison se trouve face à un conflit qu’il ne peut résoudre seul ; ceci est symbolisé par un point d’interrogation.

Par défaut, aucune action n’est réalisée et chacun demeure dans sa version d’origine.

Dans ce cas, la touche [d] permet d’afficher les différences entre les deux fichiers, [x] affiche des détails sur les fichiers (date de dernière modification, taille et permissions) et [m] permet de fusionner les fichiers.

29

02Synchronisation à distance :

Une connexion SSH doit être mise en place entre les deux machines ; chacune pourra servir à la fois de client et de serveur selon l’endroit où vous vous situez lors de la synchronisation. On veillera par ailleurs à ce que les versions d’Unison sur les deux machines concernées soient identiques (via la commande unison -version) .

Considérons une machine A sur laquelle se trouve dans votre répertoire personnel un répertoire repA, que l’on souhaite synchroniser avec un répertoire repB se trouvant sur une machine B. On utilisera une commande du type :

~$ unison repA ssh://IP_machine_distante/repB

Si repB se trouve ailleurs que dans votre répertoire personnel sur la machine distante, il faudra spécifier le chemin absolu vers ce répertoire en ajoutant un slash supplémentaire :

~$ unison repA ssh://IP_machine_distante//chemin/vers/repB

Si le nom d’utilisateur sur la machine distante n’est pas le même qu’en local, on utilisera la syntaxe :

~$ unison repA ssh://username@IP_machine_distante/repB

Il vous est alors demandé de saisir le mot de passe de la machine distante. Les modifications apparaissent quant à elles de manière tout à fait similaire au cas de la synchronisation locale.

03Créer des profils de synchronisation :

Le répertoire ~/.unison contient un fichier default.prf (vide par défaut). Ce type de fichier permet de définir des profils de synchronisation ; on peut y définir les deux chemins absolus des répertoires à synchroniser, avec la variable root.

Par exemple, si je souhaite synchroniser de façon récurrente les répertoires rep1 ou rep2 sur ma machine, je crée un fichier replocal.prf contenant :

root = /home/user/rep1
root = /home/user/rep2

Puis, pour lancer la synchronisation ultérieurement, il faudra exécuter :

~$ unison replocal

Bien entendu, un profil peut aussi contenir un chemin vers un répertoire distant, par exemple :

root = /home/user/Documents/WIP
root= ssh://IP_machine_distante/TAF/WIP

D’autres options peuvent être consignées dans un profil. Parmi les plus intéressantes :

# Pour préciser les fichiers à synchroniser (si l’on ne souhaite synchroniser qu’une partie des fichiers contenus dans l’arborescence définie pour la variable root)
path =
# Pour préciser les fichiers à ignorer lors de la synchronisation 
ignore =
# Pour accepter automatiquement les actions par défaut (en cas de modifications non conflictuelles)
auto = true
# Pour éviter toute question à l’utilisateur 
batch = true

La commande unison -help affiche l’ensemble des options disponibles.

30

07 ) Découpez, (ré)assemblez ou agrémentez vos documents PDF !

Le format PDF (Portable Document format), crée par Adobe Systems en 1993, est très largement utilisé, notamment dans un contexte professionnel, car il présente de nombreux avantages : il préserve les polices, les éléments graphiques et toute la mise en page d’un document quel que soit le logiciel utilisé pour le visualiser. Voici quelques commandes à retenir pour manipuler vos documents PDF.

01Coupez, triez, assemblez vos documents !

pdftk est souvent présenté comme le « couteau suisse » du format PDF. Et pour cause ! Il offre énormément de possibilités : fusion, découpage, rotation, chiffrement, attachement de fichiers, apposition d’un watermark, ect.

31 - pdftk

Pour fusionner plusieurs documents :

~$ pdftk doc1.pdf doc2.pdf doc3.pdf cat output fusion123.pdf

L’option cat permet de concaténer les documents passés en paramètres pour créer un nouveau PDF ; l’option output introduit le nom du document résultant. Le caractère * peut bien sûr être utilisé pour désigner l’ensemble des PDF du répertoire courant :

~$ pdftk *.pdf cat output fusion.pdf

Pour ne sélectionner que certaines pages de différents documents, puis les ré-assembler dans l’ordre spécifié dans un nouveau document :

~$ pdftk A=doc1.pdf B=doc2.pdf cat A1-3 B2-8 A5 output fusion.pdf

32 -pdftk

Nos pages demandées (3 pour le PDF 1 et 8 pour le PDF 2) ont bien été  assemblées dans un nouveau et même PDF nommé « fusion.pdf » (ce qui nous fait un total de 11 pages comme le montre l’image ci-dessous). Je sais pas pour vous si vous avez déjà essayé de modifier un PDF sous Windows, mais croyez moi, ce n’est pas aussi « simple » ….

33

Il est aussi possible de faire pivoter l’ensemble des pages d’un documents :

~$ pdftk doc.pdf cat 1-endE output doc_final.pdf

L’angle de rotation est défini par une « simple » lettre (N=0, E=90°, S=180°, W=270°, L=90, R=+90, D=+180). Notez ici l’utilisation du mot-clé end qui désigne la dernière page du document ; de même, even et odd peuvent être utilisés pour désigner respectivement les pages paires et impaires.

Pour découper un PDF en pages individuelles :

~$ pdftk doc.pdf burst

34

Normalement, nous devrions avoir notre PDF découpé en 11 pages. Allons voir ça ….

35

C’est bien le cas.  🙂

Si vous n’utilisez pas l’option output, chaque page créée sera nommé pg_0001.pdf, pg_0002.pdf, ect, comme vous pouvez le voir sur l’image ci-dessus. À vous de spécifier un format de nommage selon votre besoin.

~$ pdftk doc.pdf burst output page_%02d.pdf

02 Chiffrer un document :

Pour chiffrer un document PDF avec une clé de 128 bits (valeur par défaut), tout en conservant l’ensemble des permissions, on saisira :

~$ pdftk doc.pdf output doc_secret.pdf owner_pw

36

On ajoutera l’option allow printing en fin de ligne pour autoriser l’impression du document.

Puis, pour déchiffrer le document :

~$ pdftk doc_secret.pdf input_pw output doc.pdf

37

03 Ajouter un filigrane (watermark) :

Ceci se réalise à l’aide de l’option background, directement suivie du document comportant le filigrane (à créer).

~$ pdftk doc.pdf background mon_filigrane.pdf output doc_final.pdf

La première page du filigrane est appliquée sur chacune des pages du document d’entrée (si nécessaire, elle est redimensionnée et/ou pivotée pour s’appliquer au mieux sur le document). Notez que si le document d’entrée ne comporte pas d’arrière-plan transparent (c’est le cas des PDF générés à partir de pages scannées), l’arrière-plan ne sera pas visible ; il est alors nécessaire d’utiliser l’option stamp à la place de background.

04Agrandir un document :

pdfposter permet de répartir votre document PDF sur plusieurs pages pour en faire un poster une fois les pages assemblées.

~$ pdfposter -ma3 -pa0 doc.pdf poster.pdf

40 - pdfposter

On crée ici un poster de taille A0, constitué de pages A3, à partir d’un document PDF au format A4. L’option -m permet de définir la taille du média d’impression (A4 par défaut) : l’option -p permet de spécifier la taille du poster final. Les dimensions peuvent être exprimées de façon numérique ou via le nom du média. Pour voir la liste des différents médias :

~$ pdfposter –help-media-names

41

On peut utiliser aussi l’option -s pour spécifier un facteur de redimensionnement ; la taille du poster final sera déterminée automatiquement, inutile donc d’utiliser l’option -p simultanément :

~$ pdfposter -s4 doc.pdf poster.pdf

L’option -n permet de simuler la commande sans générer les fichiers.

05Améliorez vos présentations !

pdfcube (dans les dépôts Debian et Ubuntu) permet de visionner un fichier PDF en incluant des transittions 3D entre les pages. Pour visualiser un document PDF de cette façon :

~$ pdfcube doc.pdf

43

avant … :

42 - pdfcube

après … :

44

Votre document apparait alors en plein écran ; pour passer en mode fenêtré, utilisez la touche [F]. Les touches [A] et [C] permettent de passer d’une page à l’autre. Il est possible de programmer les transitions à l’avance, comme suit :

~$ pdfcube doc.pdf 2 5 7

Ici, le 2 signifie « entre la page 3 et 4 », le 5 signifie « entre la page 6 et 7 », ect.

Vous pourrez en outre zoomer sur les coins et le centre du document, via les touches [H], [J], [K], [L] et [Z] (pour sortir du mode zoom, il suffit d’appuyer sur la même touche). La barre d’espace vous fait passer à la page suivante avec l’effet de transition programmé ; les touches [Pg.Prèc] et [Pg.Suiv] permettent de passer à la page suivante ou précédente sans effet particulier, de même que les touches fléchées. Enfin, la touche [Échap] permet de quitter l’application.

Pour modifier les couleurs d’arrière plan (option -b) et de la face supérieure du cube (option -t) :

~$ pdfcube doc.pdf -b 0,0,0 -t 0,6,0,2,0,2

Les couleurs sont définies en valeur R.G.B (valeurs entières comprises entre 0 et 1, sans espace).

La commande wiipdf(dans les dépôts Debian et Ubuntu) permet quant à elle de contrôler la présentation d’un document PDF avec Xpdf avec une Wiimote (dépendance requise : libcwiid1). Elle prend en argument l’identifiant Bluetooth de votre Wiimote (à déterminer à l’aide de hcitool), suivi du chemin vers le fichier PDF à présenter. Pressez simultanément les boutons 1 et 2 de la télécommande pour entrer dans le mode détectable. Quand la connexion est établie, wiipdf ouvre le document dans Xpdf, en plein écran. Vous pouvez alors passer d’une page à l’autre via les boutons A et B de la Wiimote ; le bouton « HOME » permet de mettre fin à la présentation.

~$ wiipdf 00:25:A0:C0:CF:CB doc.pdf

45 - wiipdf

06Du HTML au PDF :

wkhtmltopdf est un utilitaire qui, comme son nom l’indique, sert à convertir une ou plusieurs pages(s) HTML en document PDF :

~$ wkhtmltopdf -g -l <url> doc.pdf

On génère ici un PDF en noir et blanc (option -g, pour grayscale) et en basse résolution (option -l pour lowquality). À savoir que l’option -O <orientation> permet de préciser l’orientation Portrait (par défaut) ou Landscape (paysage). On peut définir du papier via l’option -s <size> (A4 par défaut).

Linuxfrench

Voilà, nous avons terminé avec la première partie du chapitre « ligne de commandes » concernant « les fichiers« . La deuxième parties sera accès sur le « système« . 

À très vite …..

UqOi99X1

Failles Windows [1] – Shift + F10 ; (Windows 10)

images.jpg

Pirater Windows 10 avec 2 touches…. Non seulement les logiciels de Microsoft sont pleins de failles de sécurité, mais parfois ces failles sont « rigolotes ». Sam Laiho, un expert du système d’exploitation de la maison, a découvert qu’il suffit d’appuyer en même temps sur les touches [Shift] + F10 pendant une mise à jour de Windows 10 pour obtenir les droits administrateur sur le système.

cmd-admin-vista-02

La combinaison de touches permet d’avoir accès à la ligne de commande et au disque principal et au disque principal, car BitLocker censé protéger la machine est désactivé pendant la mise à jour (…ouais). Pour améliorer la sécurité de vos machines face aux pirates cagoulés, nous vous proposons de supprimer la touche [Shift] et F10 de tous les clavier !

À suivre …..

Source.

retour

 

[4] Ligne de commande – Scripts Shell

Bonjour et bienvenus dans la quatrième parties consacré à la ligne de commandes Linux. Dans celle-ci, nous allons aborder ensemble le sujet du « scripts shell ».

Au programme :

Enchaîner plusieurs commandes en écrivant un script :
l’étape suivante consiste à savoir écrire un script, en commençant par choisir les outils appropriés.

Écrire un premier script shell :
nous allons créer ici notre tout premier script, qui consiste à afficher un simple texte à l’écran. Reste à savoir comme rendre le script exécutable et comment l’exécuter ?

Rendre un script paramétrable en utilisant des variables :
le comportement d’un script peut être modifié à loisir dès lors que l’on y intègre des valeurs qui peuvent être changées comme bon vous semble.

Exécuter des commandes suivant des conditions précises :
ici encore, nous allons voir comment le comportement d’un script peut différer selon certains paramètres.

Exécuter plusieurs fois une commande sans avoir à la ré-écrire :
les premiers scripts que l’on cherche à écrire concernent souvent le traitement par lots de fichiers.

images

01 ENCHAÎNER PLUSIEURS COMMANDES EN ÉCRIVANT UN SCRIPT .

Vous savez utiliser le shell depuis une console, exécuter des commandes simples ou même plus complexes à l’aide de redirections et de pipes ( | ), mais maintenant vous voulez enchaîner les commandes. Comment faire ? Écrire un script !

1 ) Mais, c’est quoi un script ?

Comme vous avez pu le lire dans les précédents articles, lorsque vous ouvrez une console ou lorsque vous ne vous connectez pas à Linux en mode graphique, vous aboutissez sur le shell de votre système et c’est là que vous pouvez taper et exécuter vos diverses commandes.

Ces commandes admettent généralement la même structure  : le nom de la commande suivi parfois d’options (précédées du caractère ou de ) et éventuellement d’arguments.
Par exemple, dans la commande ls aild /home, ls est la commande, aild représentent les options (aild est un raccourci pour a i l d ) et /home est l’argument.

Nous souhaitons maintenant exécuter un ensemble de commandes contenues dans un fichier. Il faudrait en plus rendre paramétrable l’exécution de code à l’aide, comme nous l’avons vu précédemment, d’options et de paramètres.

Par exemple, nous pourrions avoir une commande prepare_une_boisson permettant de préparer du café, du thé,ect. Le comportement général serait le même, à quelques différences près que nous pourrions régler en fournissant un paramètre à la commande : prepare_une_boisson cafe ou prepare_une_boisson the . Et pour préciser encore plus notre attente, nous pourrions ajouter des options : prepare_une_boisson cafe –type=fort ou prepare_une_boisson the –type=earl-grey.

En plus des commandes, le shell offre la possibilité d’utiliser des structures de contrôle qui permettront de gérer de manière précise l’exécution des commandes : nous pourrons ainsi exécuter de manière répétitive un certain nombre d’entre elles et éventuellement conditionner leur exécution.

La mise en œuvre de l’ensemble des mécanismes précédemment décrits permet de créer ce qu’on appel un script shell .

shell_scripting

2 ) Quels outils utiliser pour écrire mes scripts ?

Les scripts shell sont des fichiers textes tout ce qu’il y a de plus classique. Pour créer un fichier et y insérer du texte, on a deux possibilités :

1 : La méthode « geek », tout en ligne de commandes :

~$ echo « Contenu de mon fichier texte » > fichier.txt

Ici, vous créerez un fichier nommé fichier.txt et contenant la phrase « Contenu de mon fichier texte » .Si vous souhaitez ajouter du texte, il faudra le concaténer au contenu précédent :

~$ echo « Suite de mon fichier » >> fichier.txt

1.jpg

Pour lire le contenu complet de votre fichier, vous aurez le choix entre la commande more ou la commande cat :

~$ more fichier.txt
Contenu de mon fichier texte
Suite de mon fichier

~$ cat fichier.txt
Contenu de mon fichier texte
Suite de mon fichier

2

Là où ça se corse, c’est pour modifier le contenu du fichier !
Sans utiliser des outils aussi sophistiqués que sed ou awk, vous devrez employer la commande tr permettant de rechercher dans une chaîne les occurrences d’une chaîne et de les remplacer par une autre chaîne :

~$ cat fichier.txt | tr « fichier » « petit fichier » > fichier.txt

Comme vous le voyez, cette ligne fait intervenir deux commandes (cat et tr), un pipe et une redirection… Pour frimer devant les filles quand on est au collège, ou pour faire « pro » dans les films grand public (voir la mythique scène de Jurassic Park : « It’s a Unix system…I know this »), c’est ce qu’il faut. Sinon, il faut reconnaître que c’est quand même un peu complexe pour pas grand chose ! De plus, le risque d’erreur est très élevé. On utilisera donc préférentiellement la méthode suivante.

2 : méthode dite « classique », l’utilisation d’un éditeur de texte :

Attention, si l’on parle ici d’éditeur de texte, il existe une différence avec les logiciels de traitement de texte. Un éditeur de texte est capable de lire et d’écrire du texte : chaque caractère visible (en dehors des espaces, tabulations et autres sauts à la ligne) sera visible dans le fichier. Dans un traitement de texte, des informations supplémentaires sont sauvegardées sous divers formats : police sélectionnée, taille de la police, style, ect.

Les éditeurs de texte sont conçus pour améliorer la rapidité d’écriture de lignes de codes. Pour cela, ils disposent d’une fonctionnalité de coloration syntaxique permettant d’afficher les « mots » de votre programme de différentes couleurs en fonction de leur catégorie (mot-clé, valeur numérique, opérateur arithmétique, ect) .

3

Il existe de très nombreux éditeurs de texte, plus ou moins évolués, disposant de plus ou moins de fonctionnalités. On distinguera deux catégories d’éditeurs :
► les éditeurs en mode console.
► les éditeurs en mode graphique.

Voici une liste non exhaustive de ces différents éditeurs, accompagnés de leur catégorie et d’une brève description :

Éditeurs graphiques :

gedit, kedit, nedit => Famille d’éditeurs graphiques très simples fournissant la coloration syntaxique, l’ouverture et l’enregistrement de fichiers et les copier-coller (le minimum nécessaire).

gvim => Version graphique de vim, avec l’ajout d’une barre d’outils, ect.

xmacs => Version graphique de emacs.

eclipse => Éditeur de texte « lourd » pouvant être amélioré par l’ajout d’extensions. Convient éventuellement au développement de code dans différents langages tels que Java ou C (et encore), mais certainement pas pour des scripts shell !

 ► Éditeurs en mode console :

nano => Éditeur simpliste mais qui fait son boulot .

vim => Amélioration de l’éditeur vi. Vim signifie « Vi IMproved », soit vi amélioré. Il est installé par défaut avec toute distribution Linux : quand plus rien ne fonctionne, il reste vi!
Éditeur entièrement paramétrable, améliorable par l’ajout d’extensions, contenant de nombreux raccourcis clavier permettant un développement rapide. Sa caractéristique principale est la possibilité de passer en trois modes distincts : commande (action), insertion (écriture) et visuel (sélection de code par exemple). Si je devais lui trouver un défaut, ça serait la difficulté à prendre en main lors des premiers lancement.

emacs => Équivalent de vim, développé par Richard Stallman. Chez les fanatiques, emacs est les concurrent et l’opposé de vim. Les fans d’emacs vont jusqu’à dire : « VI VI VI, le nombre de la bête ! »

Les critères de choix d’un éditeur sont propres à chacun et il est très difficile de dire qu’il vaut mieux en choisir un plutôt qu’un autre (même si vous pourrez rencontrer de très nombreux informaticiens qui vous vanteront leur éditeur, bien plus puissant et ergonomique que le vôtre !)

À titre personnel, j’utilise nano même si vim reste l’un des plus efficace bien qu’il faut accepter de passer par une longue phase d’apprentissage pour l’utiliser efficacement et il est jamais conseillé à des personnes souhaitant commencer à développer ou simplement écrire quelques scripts.

Pour un usage ponctuel, gedit, l’éditeur par défaut de l’environnement graphique GNOME, est largement suffisant ! Si vous utilisez un quelconque autre éditeur de texte régulièrement, vous maîtriserez son emploi et serez donc bien plus performant avec ce dernier, même s’il n’apparaît pas forcément comme étant le plus adapté… Continuez donc à l’utiliser !

02ÉCRIRE UN PREMIER SCRIPT SHELL .

Il faut un début à tout. Avant de se lancer dans l’écriture de scripts complexes, il vaut mieux être certain de savoir précisément ce que l’on fait. La tradition dans le monde de l’informatique est de créer un programme affichant un simple message « Hello World ! » (le fameux « Hello World ! » …). Nous ne dérogerons pas à la règle … mais nous l’adapterons.

helloworld

1 )  Comment exécuter un fichier script ?

Pour exécuter une commande shell, il existe deux alternatives :

La première méthode est aussi la moins pratique : il faut lancer un shell en lui donnant en paramètre le nom d’un fichier contenant des commandes à exécuter.
Une fois que vous aurez crée et enregistré votre script avec l’extension .sh, vous devez appeler la commande correspondant à votre shell, suivie du nom de votre script.

Supposons que nous utilisons le shell Bash et que notre script se nomme monScript.sh. La commande à exécuter sera alors :

~# bash monScript.sh

La seconde méthode consiste à indiquer directement dans le fichier quelle est la commande (le shell) qui permettra de l’interpréter. Cette solution est un tout petit peu plus longue à mettre en place (une ligne de plus à écrire), mais elle est bien plus pratique pour l’utilisateur. En effet, ce dernier n’aura qu’à écrire le nom de la commande pour l’exécuter.

Pour mettre en place cette solution, il faut indiquer sur la première ligne du fichier de script quel est l’interpréteur qui permettra d’exécuter les commandes des lignes suivantes. Cette ligne possède une syntaxe particulière : les caractères #! suivis du chemin absolu (depuis la racine) vers l’interpréteur.

Dans le cas du Bash, nous aurons comme première ligne du fichier monScript.sh :

#!/bin/bash

55-1

Toutefois, pour que le mécanisme fonctionne, vous devrez rendre ce script exécutable (attention à la gestion des droits utilisateurs (u), groupe (g) et autres (o)). Il faut utiliser la commande chmod pour modifier les droits d’un fichier en lecture (r), écriture (w) et exécution (x). Cette commande, que vous pourrez voir plus en détail dans un article suivant, peut être utilisée de deux manières que nous allons tester sur le script monScript.sh .

La première méthode consiste à garder les droits actuels du fichier et à ajouter ou à retirer des droits en fonction des utilisateurs :

~# chmod u+x monScript.sh; chmod o-rw monScript.sh; ls -al monScript.sh

5-2

Dans cet exemple, nous avons pris le fichier monScript.sh avec les droits qui lui avaient été affectés par défaut (si vous n’avez pas modifié le masque, ces droits sont lecture et écriture pour l’utilisateur et le groupe et seulement lecture pour les autres), puis nous avons ajouté le droit d’exécution pour l’utilisateur et retiré les droits de lecture et d’écriture pour les autres. Au final, les droits du fichier sont donc lecture, écriture et exécution pour l’utilisateur, lecture et écriture pour le groupe  et aucun droit pour les autres.

La seconde méthode consiste à indiquer sous forme de codage octal les droits de chaque groupe dans l’ordre utilisateur, groupe, puis autres. Un code octal commence par le chiffre 0, puis un chiffre en base 8 pour les droits de chaque groupe : 0 pour aucun droit, 1 droit d’exécution, 2 droit d’écriture, 4 droit de lecture, ou une combinaison de ces droits.

Une fois que vous aurez ajouté la ligne indiquant le programme capable d’interpréter votre script et que vous aurez donné les droits en exécution à votre fichier, il ne vous reste plus qu’à taper le nom de votre fichier dans un terminal pour celui-ci soit exécuté …

2 ) Premier script : « Hello GNU/LINUXIENS !« 

Nous allons maintenant pouvoir réaliser notre premier script shell.

Pour que l’exemple reste le plus simple possible, nous allons seulement utiliser la commande d’affichage echo. Cette commande admet pour paramètre une chaîne de caractères qu’elle imprimera sur le périphérique de sortie standard (par défaut, il s’agit de l’écran). Nous pouvons utiliser cette commande en shell interactif en tapant directement après le prompt :

~$ echo « Hello GNU/LINUXIENS ! »

6.jpg

Pour créer un script qui exécutera cette même commande, il faut ouvrir un fichier texte (que nous appellerons ici hello.sh) :

~# nano hello.sh

et y ajoutez-y ceci à l’intérieur :

#!/usr/bin/bash

# Nous allons afficher un message !
echo « Hello GNU/Linuxiens ! »

6-1

Les caractères  de la ligne 3 qui suivent le caractère # ne sont pas interprétés (sauf cas spécial du shebang de la première ligne). Ainsi la phrase de la troisième ligne constitue un commentaire permettant d’indiquer à un lecteur, éditeur (nous sommes dans l’open-source ! Ne l’oublions pas.) du fichier ce qu’on a souhaité réaliser.

On ne soulignera jamais assez l’importance des commentaires dans un code : le message permettra peut être d’aider un développeur qui veut améliorer votre script, ou plus simplement, il vous aidera vous ! En effet, si vous délaissez un script quelques temps, puis que vous y revenez pour corriger un bug ou y apporter une amélioration, vous serez heureux de retrouver ces petits messages vous indiquant ce que fait le code, pourquoi avoir choisi d’exécuter telle commande plutôt que telle autre. Et ne croyez pas qu’il faille laisser passer beaucoup de temps pour « oublier » la structure d’un code pour pouvoir le maintenir et augmenter sa durée de vie (un code in-maintenable n’évolue plus et il est voué à une mort certaine).

Notez que les commentaires ne commencent pas forcément une ligne. En ligne 4, nous aurions pu écrire :

echo « Hello GNU/Linuxiens ! » # Ceci est un commentaire

7

Les lignes vides ne sont pas interprétés non plus : utilisez-les pour aérer votre code et le rendre plus lisible en regroupant les lignes de même « fonction« . Comme dans un texte, vous aurez ainsi des « paragraphes » permettant de faciliter la lecture.

Pour tester le script, rendez votre fichier exécutable avec la commande chmod comme vu précédemment :

~# chmod u+x hello.sh

puis lancez votre script simplement à l’aide de la commande :

~# bash hello.sh

8

Bien sûr, tout ceci ne constitue que la base de l’élaboration des scripts, mais nous voyons que nous pouvons déjà enchaîner des commandes que nous tapions précédemment dans le shell : il suffit de créer un fichier et d’y écrire les commandes dans l’ordre dans lequel on souhaite qu’elles s’exécutent.

Par exemple, nous pouvons modifier notre exemple ou en créer un nouveau script que nous nommerons hello2.sh de manière à ce qu’il se déplace dans le répertoire home/votre_login/Documents et qu’il crée un fichier hello.txt contenant la phrase « Hello GNU/Linuxiens ! » :

#!/usr/bin/bash

# Déplacement dans le répertoire /home/votre_login/Documents
cd /home/LinuxFrench/Documents

# Création du fichier
echo « Hello GNU/Linuxiens ! » > hello.txt

# Affichage d’un message
echo « le fichier hello.txt a été crée… »

On vérifie :
(n’oubliez pas de rendre votre script exécutable!)

~# bash hello2.sh; ls /home/votre_login/Documents/hello.txt; cat /home/votre_login/Documents/hello.txt

910

0403RENDRE UN SCRIPT PARAMÉTRABLE EN UTILISANT DES VARIABLES .

Un script permet de placer des commandes dans un fichier et de les exécuter … Mais si l’on ne peut pas faire varier légèrement son comportement en changeant des valeurs comme des chaînes de caractères ou des nombres, l’intérêt est très limité. Heureusement pour nous, il existe les variables.

01 ) Qu’est-ce qu’une variable ?

Une variable n’est jamais qu’un espace réservé en mémoire dans lequel on peut écrire des données. Pour accéder plus simplement à cet espace, on lui donne un nom (utiliser une adresse du type 0x278faa0 est nettement moins pratique !). On peut voir une variable comme une boite sur laquelle on colle une étiquette portant un nom.

Si nous plaçons dans notre boite un carré de chocolat et que nous inscrivons sur l’étiquette « miam_miam« , nous pourrons dire « Tiens, je mangerais bien un miam_miam » et cela se traduira par « Tiens, je mangerais bien un carré de chocolat« . Le fait de modifier le contenu de la boite modifiera le sens de notre phrase. Si nous plaçons maintenant dans la boite un kiwi, la traduction donnera « Tiens, je mangerais bien un kiwi« . ainsi, nous pouvons décrire une seule fois notre action et le rendre paramétrable à l’aide d’une variable qui se nomme ici miam_miam.

Pour revenir dans un cadre un peu plus formel, une variable est définie par un identifiant (son nom) et une valeur (son contenu). Lorsque l’on définit une variable, on réserve un espace mémoire (par exemple 0x278faa0) et on lui associe un nom (par exemple miam_miam), puis on y stocke une valeur (le « carré de chocolat » de l’exemple précédent). Lorsque nous utiliserons notre variable, l’interpréteur lira le nom de la variable, le traduira en adresse mémoire et ira rechercher l’information en mémoire à l’emplacement indiqué.

Passons maintenant à un aspect plus pratique et voyons la syntaxe à utiliser pour manipuler des variables.

02 ) Créer une variable .

La définition d’une variable se fait de manière très naturelle, comme en mathématique : identifiant=valeur (attention de ne surtout pas mettre d’espace entre la fin du nom de la variable et le signe égal !). La valeur pourra bien sûr être un nombre, une lecture ou chaîne de caractères (encadrée par des guillemets « … » ou des quotes « … ») ,ect.

Pour utiliser la valeur contenue dans une variable, il faudra la faire précéder du caractère $. Ainsi, si la variable a vaut 15, pour accéder à la valeur de a je devrais écrire $a.

reprenons l’exemple utilisé pour notre premier script (hello.sh), où le texte à afficher sera cette fois placé dans une variable :

#!/usr/bin/bash

msg=« Hello GNU/Linuxiens ! »
echo $msg

11

msg est la variable contenant la chaîne de caractères « Hello GNU/Linuxiens ! » et $msg représente le contenu de la zone mémoire référencée par le nom de la variable msg. Ainsi, lors de l’exécution, $msg sera remplacé par la valeur « Hello GNU/Linuxiens ! » et nous exécuterons donc echo « Hello GNU/Linuxiens ! ».

Il également possible d’exécuter des opérateurs sur les variables. Si les variables sont des entiers, on pourra utiliser les opérateurs arithmétiques classiques, plus % pour le reste de la division entière et ** pour la puissance. La syntaxe est alors un peu particulière et il y a deux manière de faire :

01 ► soit on encadre l’opération par $((…)), ce qui donne par exemple : a=$((7+8))
02 ► soit on utilise la commande let <> : let <<a=7+8>>

Dans le cas des chaînes de caractères, pour réaliser une concaténation (coller des chaînes bout à bout), il suffit de mettre les variables côte à côte. Par exemple si a=>>GNU/>> et b=>> Linuxiens>>, alors on peut écrire msg=$a$b et la variable msg contiendra la valeur « GNU/Linuxiens ».

Voici un tableau récapitulatif indiquant la valeur d’une variable après les opérations vues en exemple :

01 )
► COMMANDE => var=7+8
VALEUR DE LA VARIABLE => 7+8
(résultat de : echo $var)02 )
COMMANDE => let <<var=7+8>>
VALEUR DE LA VARIABLE => 1503 )
COMMANDE => var=$((7+8))
► VALEUR DE LA VARIABLE => 1504 )
COMMANDE => a=>>Hello GNU/>>
                                  var=$a>>Linuxiens>>
VALEUR DE LA VARIABLE => GNU/Linuxiens05 )
COMMANDE => a=>>Hello GNU/>>
                                  b=>>Linuxiens>>
                                  var=$a$b
VALEUR DE LA VARIABLE => Hello GNU/Linuxiens

03 ) Les différents types de variables.

3.1Les variables d’environnement :

Les variables d’environnement sont notées en majuscules. La partie 02 de la série d’articles sur la « ligne de commandes » explique déjà assez longuement à quoi servent ces variables. Sachez simplement que, d’un point de vue syntaxique, pour avoir accès à leur valeur, vous pourrez les utiliser comme des variables « normales » en préfixant leur nom par le caractère $.

3.2Variables spéciales :

Il existe un certain nombre de variables spéciales qui sont initialisées au lancement de chaque script. Voici un tableau les résumant :

VARIABLE => $0
DESCRIPTION => le nom du script (par exemple, si le script se nomme monScript.sh et qu’il est appelé depuis son répertoire de stockage, la valeur de $0 sera ./monScript.sh)► VARIABLE => $1, $2, …
DESCRIPTION => les arguments passés au script : $1 est le premier argument, ect.► VARIABLE => $*
DESCRIPTION => la liste de tous les arguments passés au script, séparés par un espace.► VARIABLE => $#
DESCRIPTION => le nombre d’arguments passés au script.► VARIABLE => $7
DESCRIPTION => le code de retour de la dernière commande exécutée. Toutes les commandes shell renvoient une valeur : 0 lorsque la commande s’est exécutée correctement et sinon, un code d’erreur compris entre 1 et 255. Par exemple, après un appel à ls , $? contiendra la valeur 0. Par contre, après un appel à ls /rep_inexistant , $7 contiendra la valeur 2 (on suppose que le répertoire /rep_inexistant n’existe pas, bien sûr).► VARIABLE => $!
DESCRIPTION => le numéro de processus de la dernière commande lancée en tâche de fond.► VARIABLE => $$
DESCRIPTION => le numéro de processus du script lui-même.

Grâce à ces variables, l’utilisateur pourra transmettre des données au script sans pour autant avoir à modifié le script. On peut donc définir des actions génériques, que l’on modifiera lors de l’appel en indiquant un ou plusieurs arguments.

Voici un exemple très simple permettant de voir le contenu de ces variables en fonction des arguments passés lors de l’appel du script.
Nous nommerons ce script variables.sh :

#!/bin/bash

echo « Le script s’appelle » $0
echo « Vous avez passé » $# « arguments. »
echo « La liste de ces arguments est : »
echo $*
echo « Le premier argument est : » $1
echo « Le deuxième argument est : » $2

12

Lors de l’exécution de ce script, si vous lui passez en paramètres quelques valeurs, vous obtiendrez l’affichage suivant :

~# bash variables.sh arg1 arg2 arg3
Le script ………
……………………………
………………………………………

12-1

Si, plutôt que de transmettre les données au script sous forme d’arguments, vous préférez demander à l’utilisateur de les saisir au clavier durant l’exécution de votre code, vous pourrez le faire grâce à la commande read .Cette commande permet de lire des données au clavier et de les stocker dans une variable dont le nom est spécifié à la suite de la commande : read nomVariable. La variable contenant la saisie utilisateur sera alors utilisée comme n’importe quelle variable en la préfixant par le caractère $ pour avoir accès à sa valeur.

Voici un exemple utilisant la commande read :

#!/usr/bin/bash

echo « Comment vous appelez-vous ? »
read nom
echo « Salut » $nom

13

À la lecture de la ligne 4, l’exécution du script sera suspendu jusqu’à ce que l’utilisateur ait saisi un texte et qu’il l’ait validé en appuyant sur la touche . Le texte sera alors stocké dans la variable nom et l’exécution du script reprendra en ligne 5 pour afficher le message.

Ce qui nous donne :

~# bash read.sh
Comment vous-appelez vous ?
………………
………………………………..

14

La commande read peut être utilisée pour réaliser une pause dans un programme en demandant à l’utilisateur d’appuyer sur la touche pour continuer. Ici, on ne souhaite pas récupérer la saisie dans une variable puisque cette dernière ne sera pas utilisée. Inutile dans ce cas de gaspiller de la mémoire, on ne précise pas de nom de variable :

echo « Appuyer sur pour continuer… »
read

04 EXÉCUTER DES COMMANDES SUIVANT DES CONDITIONS PRÉCISES.

Dans un script, il se peut que l’on veuille effectuer des actions différentes en fonction d’une valeur calculée ou transmise par l’utilisateur. Par exemple, à la question « Voulez-vous quitter le programme (O/N) ?« , il est bien évident que l’action à déclencher sera différente suivant que l’utilisateur réponde par l’affirmative ou la négative. Grâce aux structures conditionnelles nous allons pouvoir gérer ces cas.

01 ) La construction des structures conditionnelles.

Pour conditionner l’exécution de lignes de code, on utilise l’instruction if, qui se traduit par « si » et qui s’écrit de la manière suivante :

if condition; then
   …
fi

Les lignes encadrées par la ligne if et la ligne fi (if à l’envers) forment ce que l’on appelle « un bloc » : elles seront toutes exécutées (ou aucune) suivant que la condition du test soit vérifiée ou non. Le caractère point-virgule, qui suit la définition de la condition à vérifier, permet de séparer plusieurs commandes sur une même ligne.

L’instruction then (qui signifie « alors« ) étant une nouvelle instruction, il faut la séparer du début de ligne par un point-virgule. Sans ce caractère, il aurait fallu utiliser une notation moins compacte :

if condition
then
   …
fi

Cette structure permet donc d’exécuter des instructions au cas où la condition est vérifiée. Dans le cas où elle est invalidée, si vous souhaitez effectuer un autre traitement, il faudra utiliser l’instruction else dans une structure « si condition alors … sinon … » :

if condition; then

else
   …
fi

Enfin, on peut imbriquer les tests dans des structures de type « si condition_1 alors … sinon, si condition_2 alors sinon, si … ect. » :

if condition_1;   then
    …
elif condition_2;   then
    …
elif   …ect…
    …
fi

15

Nous avons vu la syntaxe permettant d’écrire des structures  contenant des embranchements s’activant en fonction de conditions …Il reste donc à voir comment écrire une condition pour pouvoir réellement utiliser ce mécanisme.

Une condition, encore appelée test, peut s’écrire de deux manières différentes :

► soit en l’encadrant par des crochets […]
► soit en utilisant la commande test …

Une fois la syntaxe choisie, en conjuguant cette écriture avec un opérateur de test, on obtient une condition. Avec des nombres par exemples, les opérateurs de test permettront d’écrire « Est-ce que a est plus petit que b ?« . L’opérateur « plus petit que » s’écrit -lt .

Voici un exemple de condition où nous employons les deux syntaxes décrites précédemment :

[ 2 -lt 3 ]
test 2 -lt 3

Ces deux lignes sont identiques et testent si 2 est inférieur ou égal à 3. Dans tout test, une condition vérifiée renverra 0 et sinon, un entier quelconque différent de 0. Si vous voulez vous en assurer, vous pouvez afficher le contenu de la variable spéciale $? après avoir exécuté un test :

~$ [2 -lt 3 ]
~$ echo $?
0

16

Si le nombre d’arguments est inférieur à 2 (ligne 3), alors on affiche un message d’erreur (ligne 4) et sinon, on affiche le nombre d’arguments (ligne 6).

02 ) Les opérateurs test.

Les opérateurs de test se répartissent en trois catégories : les opérateurs arithmétiques dont nous avons pu voir un exemple avec -lt, les opérateurs de test de fichiers, et les opérateurs logiques permettant de créer des conditions complexes.

02.1 – Les opérateurs arithmétiques :

L’opérateur arithmétique -lt, que nous avons déjà vu, signifie « low than » soit « inférieur à« ; Les autres opérateurs sont construits sur le même modèle : -gt pour plus grand que (greater than), -eq pour égal (equal), -ne pour différent de (not equal), -ge pour plus grand ou égal à (greater or equal), -le pour plus petit ou égal à (lower or equal).

Sachez que ces opérateurs sont des opérateurs arithmétiques et fonctionnent donc avec des nombres. Si vous voulez effectuer des tests sur des chaînes de caractères, vous devrez utiliser des opérateurs différents : == pour l’égalité et != pour la différence.

02.2 – Les opérateurs de test de fichiers :

Les opérateurs de test de fichiers permettent d’obtenir très facilement des informations sur les fichiers. Il s’agit la plupart du temps d’opérateurs unaires portant sur le nom d’un fichier. Voici quelques-uns de ces opérateurs :

-e : pour vérifier l’existence d’un fichier (exists).
-f : pour vérifier l’existence d’un fichier et qu’il s’agisse bien d’un fichier et pas d’un répertoire par exemple (file)
-d : pour vérifier l’existence d’un répertoire (directory).
-r : pour vérifier si un fichier est accessible en lecture (readable).
-w : pour vérifier si un fichier est accessible en écriture (writable)
-x : pour vérifier si un fichier a les droits d’exécution (executable).

02.3 – Les opérateurs logiques :

Les opérateurs logiques permettant de composer des conditions plus « complexes » à l’aide des opérateurs booléens « et« , « ou » et « non« .

L’opérateur « non » est un opérateur unaire : il n’accepte qu’un seul argument dont il va inverser la valeur retour . Si une conditions est vraie, alors elle sera fausse et inversement. Le symbole de cet opérateur est !.

Si vous voulez tester si 10 est supérieur ou égal en 5 en ne connaissant que l’opérateur -lt (inférieur à), il faudra prendre la négation de la condition : [ ! 10 -lt 5 ].

Les opérateurs « et » et « ou » sont des opérateurs binaires permettant de composer des conditions « si condition_1 est vraie et/ou si condition_2 est vraie, alors …« . On utilise && ou -a pour l’opérateur « et » et || ou -o pour l’opérateur « ou« . Ces opérateurs peuvent être combinés à l’infini.

Pour tester si une variable var est comprise entre 1 et 10, on utilisera le test :
[ $var -ge 1 ] && [ $var -le 10 ].

Enfin, une commande permet d’obtenir la liste complète des opérateurs arithmétiques, de test de fichiers et logiques disponibles pour la création de conditions :

~$ info coreutils ‘test invocation’

1717-1

03 ) La structure case .

Il n’existe pas que l’instruction if pour créer des structures conditionnelles : pour les structures à choix multiples, il existe la structure case permettant d’effectuer un branchement sur des lignes de codes en fonction de la valeur contenue dans une fonction.

On peut voir cette structure comme un grand aiguillage ferroviaire, dont le numéro de voie est donné par le contenu d’une variable. Au niveau syntaxique, la valeur de la variable pour chaque cas possible sera suivie d’une parenthèse fermante et le bloc d’instructions à exécuter pour ce cas se situera entre la parenthèse fermante et les caractères ;; (une instruction vide signifiant la fin du bloc).

Appliquons cette définition à un exemple : la variable choix peut valoir 1,2,3 ou 4 et l’action à effectuer sera simplement d’afficher le chiffre correspondant en toutes lettres pour les valeurs 1 à 3 et d’afficher le message « coucou » pour la valeur 4. Dans tous les autres cas, nous afficherons un message d’erreur.

Voici le code correspondant à cet exemple :

#!/bin/bash

echo « Donnez un chiffre entre 1 et 4 : »
read choix

case $choix in
1)   echo   « un »;;
2)  echo   « deux »;;
3)  echo    « trois »;;
4)  echo    « coucou »;;
*)  echo    « ERREUR ! »
esac

1818-1

Le dernier cas, en ligne 11, correspond au choix par défaut : si l’utilisateur saisit autre chose qu’un entier entre 1 et 4, c’est cette action qui sera effectuée. L’utilisation du caractère * pour indiquer tous les cas différentes de ceux traités (on dira « filtrés« ) auparavant, vient du fait qu’il s’agit en fait d’expressions régulières. En ligne 12, on referme le bloc case en inscrivant le nom de l’instruction à l’envers : esac .

04 EXÉCUTER PLUSIEURS FOIS UNE COMMANDE SANS AVOIR À LA RÉ-ÉCRIRE.

Une boucle permet de répéter une action , une commande ou un bloc de commandes un certain nombre de fois. Ces commandes pourront être exécutées à l’identique ou paramétrées à l’aide de variables qui évolueront à chaque passage dans la boucle. Si vous voulez afficher les 100 premiers résultats de la table de multiplication par 7, vous n’allez certainement pas écrire 100 lignes de code et calculer « à la main » les résultats ! D’où l’intérêt des boucles …

01 ) Les structures de base.

Le shell propose deux structures de boucles « simples » dont le fonctionnement général est identique : un bloc de commandes va être exécuté jusqu’à ce qu’une condition change d’état.

01.1 L’instruction « while » :

La première des structures de boucle est composée à l’aide de l’instruction while et signifie « tant que la condition est vérifiée, faire…« .

Dans le cas proposé en exemple, l’écriture des cents premiers résultats de la table de multiplication par 7, nous allons avoir besoin d’une variable i qui sera incrémentée et sera multipliée par 7 à chaque étape. La condition sera donc : « tant que i est inférieur ou égal à 100, faire…« . La traduction en script shell donne :

#!/bin/bash

i=1

while $i -le 100 ];  do
              echo  $i« *7= »$(($i*7))
              i=$(($i+1))
done

2020-1

En ligne 3, nous commençons par initialiser une variable i avec la valeur 1. Cette variable va nous permettre de compter de 1 à 100 pour effectuer nos calculs. Ce décompte va être contrôlé par la condition d’arrêt de notre boucle en ligne 5, qui peut être traduite par « tant que i est inférieur ou égal à 100, faire » . Vous reconnaîtrez dans l’écriture de la condition la syntaxe que nous utilisons avec les structures conditionnelles. Nous pouvons ensuite réaliser l’afficher en ligne 6 et surtout, ne pas oublier d’incrémenter la variable de boucle en ligne 7, de manière à pouvoir sortir de la boucle à un moment donné.

01.2L’instruction « until » :

La deuxième structure de boucle est la structure until, qui se rapproche énormément de la boucle while… à la différence prêt que la condition d’arrêt n’est pas interprétée de la même manière. En effet, until signifie « jusqu’à ce que… » et la boucle sera donc exécutée jusqu’à ce que la condition soit vérifiée (au contraire de la boucle while qui s’exécute tant que la condition est vérifiée).

Reprenons l’exemple utilisé précédemment avec le while : vous constaterez qu’une ligne sera modifiée. Mais attention : la condition a été inversée ! On passe ainsi de « tant que i < 100 » à « jusqu’à ce que i > 100« .

#!/bin/bash

i=1

until     [ $i -gt 100 ]; do
              echo  $i« *7= »$(($i*7))
              i=$(($i+1))
done

21
02 ) Parcourir une liste.

Le shell propose des instructions permettant de parcourir simplement une liste.

02.1 L’instruction « for » :

Cette structure s’éloigne un peu des deux types de boucles vus précédemment : ici, nous allons parcourir une liste d’éléments (chaînes de caractères, entiers ou mélange de plusieurs types). Une liste est spécifiée par une suite d’éléments séparés par un espace.

Voici un exemple de liste :

« chaîne » 1 2 « autre chaîne » 3 4 5

L’utilisation du caractère * permet d’obtenir un élément de type liste : les fichiers du répertoire courant. Il s’agit d’un joker qui peut être également combiné avec d’autres caractères *.py renverra par exemple la liste des fichiers Python du répertoire courant,  script* renverra  la liste des fichiers dont le nom commence par « script ». Pour parcourir les fichiers d’un répertoire, vous pourrez donc utiliser for en association avec le caractère *.

La construction de la boucle se fait à l’aide d’une variable qui va prendre consécutivement pour valeur les éléments de la liste. La syntaxe sera la suivante : for variable in liste; do que nous pourrions traduire par « pour la variable nommé variable prenant ses valeurs dans la liste, faire…« . N’oubliez pas que lors de l’utilisation de la variable, il faut préfixer son nom par la caractère $.

Voici par exemple comment afficher et compter les fichiers du répertoire courant à l’aide de cette structure :

#!/bin/bash

i=1

for file in *; do
          echo $i« . « $file
          i=$(($i+1))
done

2222-1

En ligne 5, le caractère * va être remplacé par la liste des fichiers. À chaque itération, la variable file va changer la valeur et contenir le nom d’un des fichiers du répertoire courant. Donc, à la première itération, $file désignera le premier fichier, puis à la deuxième itération, le deuxième fichier, et ainsi de suite.

02.2 L’instruction select pour une boucle un peu particulière :

L’instruction select est une sorte d’amélioration du for pour des cas particuliers. En effet, elle permet de proposer à l’utilisateur de saisir un choix dans une liste qui sera affichée à l’écran. Sans commande d’arrêt (que nous verrons par la suite), la demande saisie sera infinie.

Voici un exemple simple :

#!/bin/bash

select choix in « entrée 1 » « entrée 2 » ; do
         echo « Vous avez choisi » $choix
done

22

Lors de son exécution, ce script va réaliser l’affichage suivant :

22-1

Vous pourrez saisir votre choix après le point d’interrogation et la variable choix prendra pour valeur votre saisie (à condition que cette dernière fasse partie des choix possibles ; (1 & 2)).

Attention: vous devez taper le numéro correspondant à votre choix et la variable choix ne contiendra pas ce numéro mais le contenu correspondant à cet indice !

Comme dit précédemment, ce script boucle à l’infini et demandera toujours à l’utilisateur de saisir un choix. Pour arrêter la boucle, il faut utiliser break.Le menu ressemblera alors à:

#!/bin/bash

select choix in « entrée 1 » « entrée 2 » « q »; do
                  case $choix in
             « entrée 1 » | « entrée 2 ») echo « Vous avez choisi » $choix;;
            « q ») echo « Au revoir… »
                  break;;
             *) echo « Saisie non valide ! »
                    esac
done

2424-1

Ainsi, avec ce genre de structure, on assure que la boucle sera exécutée tant que l’utilisateur ne saisit pas un choix valide et que le menu sera ré-affiché jusqu’à ce que l’utilisateur sélectionne le choix 3 (test de la ligne 6 et sortie de la boucle select par le break de la ligne 7). Si vous souhaitez également interrompre la boucle dès qu’un choix valide a été sélectionné, vous pouvez également utiliser des break.

Créer une structure équivalente à l’aide des instructions for et while serait légèrement plus complexe :

i=1
for choix in « entrée 1 » « entrée 2 » « q » ; do
              echo $i« ) » $choix
             i=$(($i+1))
donewhile [ 1 ]; do
                   echo -n « #? « 
                   read choix
                   case $choix in
                   1 | 2) echo « Vous avez choisi l’entrée n. » $choix;;
                   3) echo « Au revoir… »
                            break;;
                   *) echo « Saisie non valide ! »
              esac
done

 

Il faut commencer par afficher les choix possibles (ligne 1 à 5), puis rentrer dans une boucle infinie en ligne 7 dont la condition d’arrêt est [ 1 ] (qui est toujours vrai) et enfin, demander à l’utilisateur de saisir un choix (notez l’usage de l’option -n de echo en ligne 8 pour désactiver le retour chariot) et traiter ce choix. Comme ici il n’y pas de correspondance entre le numéro saisi et la valeur du choix, nous récupérons dans la variable $choix que le numéro saisi. Dans ce cas particulier, il est donc bien plus pratique d’utiliser l’instruction select !

2525-1

CHOSES À RETENIR ET ASTUCES :

► Un éditeur de texte ne sauvegarde que le texte tapé au clavier. Un logiciel de traitement de texte tapé au clavier, ainsi que sa mise en forme (police, style, ect.).

► Dans les éditeurs de texte, la coloration syntaxique ne s’active en général qu’une fois le fichier enregistré avec la bonne extension (.sh pour les scipts shell).
Commencez donc par enregistré votre fichier avant de taper la moindre ligne de code !

► Les caractères #! sur la première ligne d’un fichier indiquent au système que ce fichier est un script qui doit être interprété par le programme indiqué à la suite sur cette même ligne, appelée « shebang »
À la lecture de la ligne #!/bin/bash, le système va exécuter la commande /bin/bash et lui fournir en entrée de lignes suivantes du fichier.

► Pensez à commenter abondamment vos lignes de code ! Elles vous semblent évidentes au moment où vous les écrivez, mais si vous devez relire votre programme plus tard, elles vous paraîtront nettement moins compréhensibles.

► Comme le shell est sensible à la case (différence majuscules/minuscules), il est d’usage de n’utiliser que des caractères minuscules pour nommer ses variables. Les noms en majuscules sont réservés aux variables d’environnement.

PASSER DES ARGUMENTS À UN SCRIPT :
Les variables spéciales $1, $2, … $n permettent de récupérer les arguments transmis à un script lors de son appel. La correspondance entre les noms de variables et les arguments se fait en fonction de la position de ces derniers :
~$ monScript.sh argument1 argument2 argument3 s0 s1 s2 s3

LES DANGERS DE LA COMMANDE READ :
En employant la commande read suivie de plusieurs noms de variables, vous pourrez récupérer plusieurs valeurs saisies par l’utilisateur, le caractère espace faisant office de délimiteur. Mais attention ! Si l’utilisateur donne plus de valeurs que ce qu’il n’y de variables dans la commande read, votre dernière contiendra tous les caractères restants. Voici un petit exemple illustrant le principe :
~$ echo « Saisir a et b: »; read a b; echo « a = » $a « et b = » $b GNU/Linuxiens a = GNU/ et b = Linuxiens
~$ echo « Saisir a et b: »; read a b; echo « a « et b= » $b GNU/Linuxiens test de variables a = GNU/Linuxiens et b = test de variables

► ATTENTION AUX ESPACES !
Lors de l’écriture de conditions en la syntaxe […], faites très attention à bien laisser un caractère espace après le crochet ouvrant et avant le crochet fermant :
~$ [2 -lt 3]
[2 : commande introuvable
~$ [ 2 -lt 3]
bash: [:  » ]  » manquant
~$ [ 2 -lt 3 ]
La dernière ligne ne renvoie pas d’erreur et fonctionne donc correctement.

► Chaque passage dans une boucle s’appelle une itération et si la condition d’arrêt porte sur une variable, cette dernière se nomme variable de boucle.
Il faut faire très attention à ce que la condition d’arrêt de la boucle puisse changer d’état à un moment donné, sinon votre script rentrera dans une boucle infinie et vous ne pourrez l’arrêter qu’à l’aide de [Ctrl]+[C]. Ce genre de condition dépend en général d’une variable de boucle qu’il faudra prendre soin de faire évoluer au cours des itérations (soit en l’incrémentant, soit en la décrémentant.)

► À chaque fois que vous utilisez le caractère * dans une commande shell, celui-ci est remplacé par la liste des fichiers du répertoire courant. Par exemple, si votre répertoire contient trois fichiers : monFichier.txt ; monTest.sh et monTest.py, le caractère * dans une commande sera remplacé par la liste de ces fichiers :
~$ echo mo*
monFichier.txt monTest.sh monTest.py

Voilà, nous en avons terminé pour cette quatrième parties.

La cinquième parties sera accès sur la recherche de fichier, la gestion des utilisateurs, la gravure et l’encode de CD/DVD et il y aura une partie sur le réseau (interfaces, SSH, bureau à distance-graphique, partage de fichiers et la sauvegarde de données.)

À très vite … Merci.

logo_gnu_linux_pratique

[3] Lignes de commandes – Prérequis.

À découvrir dans cette partie …..
(au passage, merci car vous êtes de plus en plus nombreux à me lire et donc, je l’espère pour certains, à se lancer enfin dans le monde du logiciel libre et de Linux).

Toutes les commandes de base pour manipuler ses fichiers.
Lorsque l’on s’initie à la ligne de commandes, il est nécessaire de commencer par les commandes incontournables, à savoir celles qui sont liées à des tâches courantes comme la création de fichiers ou de répertoires, la copie ou la suppression de fichiers, l’accès au contenu d’un fichier, mais aussi toutes les commandes qui permettent de se déplacer rapidement dans l’arborescence de votre système. Vous trouverez donc ici le récapitulatif des principales commandes à connaître pour bien débuter.

Pour se familiariser avec la ligne de commandes, rien de tel que d’effectuer quelques opérations simples sur les fichiers et répertoires, histoire de bien maitriser son environnement, de pouvoir se balader dans son système de fichiers et d’organiser ses documents en toute facilité.

01 ► NAVIGUER PARMI SES FICHIERS :

1

1.1 ) Chemin absolu ou relatif ?

Pour indiquer un fichier au shell, sachez que son nom seul ne suffit pas… À moins de se trouver dans le même répertoire que le fichier en question.

La référence exacte à un fichier est appelée « chemin » (c’est en quelque sorte son adresse, son emplacement dans le système) ; il indique précisément dans quel répertoire se trouve le fichier. Sous Linux, les noms des répertoires et des fichiers au sein d’un chemin sont séparés par un slash / (contrairement aux systèmes Windows, où le séparateur est un anti-slash \).

Notez que plusieurs fichiers peuvent porter le même nom, du moment qu’ils ne se situent pas à la même adresse (même répertoire donc) .

On distingue ainsi deux types de chemins :

=> un chemin absolu prend pour référence le début de l’arborescence de fichiers, à savoir la racine ; il commence donc toujours par le symbole / .

=> un chemin relatif dépend du répertoire courant où se trouve l’utilisateur au moment où il fait référence au fichier.

1-1

Considérons par exemple le schéma du dessus avec quelques rajouts logique. Si l’on souhaite faire référence au fichier de chemin absolu /home/marc/Musique/rock/track1.mp3 alors que l’on se situe dans le répertoire /home/marc/Images/ ,on fera appel au chemin relatif suivant : …/Musique/rock/track1.mp3 .

Si, alors qu’il se situe dans le répertoire Images/, Marc saisit la commande suivante :

~/Images$ rythmbox track1.mp3

Le système répondra que le fichier n’existe pas (car aucun fichier du nom track1.mp3 ne se trouve dans le répertoire courant qui est Images/ ).

En revanche, si Marc se trouve dans le répertoire rock/ et qu’il souhaite écouter le fichier track1.mp3, il peut tout à fait saisir son nom seul ici, puisque relativement, il n’y a que cette possibilité.

~/rock$ rythmbox track1.mp3

1.2 ) Mais …où suis-je ?

Pour connaître à tout moment le chemin absolu du répertoire où l’on se situ, il suffit de saisir la commande pwd (print working directory).

À savoir que par défaut, le terminal que vous utilisez s’ouvre toujours sur votre répertoire personnel à son lancement.

Pour se déplacer d’un répertoire à un autre on utilise la commande cd (change directory) suivie du nom (ou du chemin) du répertoire de destination :

~$ cd /home/linuxfrench/

2

Pour vous rendre dans votre répertoire personnel, quel que soit l’endroit où vous vous situez, vous pouvez saisir simplement :

~$ cd ~
(ou créer un alias comme vu dans la deuxième partie de cette série d’article « lignes de commandes« . => alias cdd=’cd ~’ *wink*)

Le symbole ~ remplace en effet le chemin absolu vers votre répertoire personnel. Mais on pourra saisir simplement :

~$ cd

Et pour revenir au répertoire précédent, on utilise le tiret, comme ceci :

~$ cd
ou alors :
~$ cd ..

3

02 ► CRÉER ET SUPPRIMER UN RÉPERTOIRE :

Ce n’est pas plus compliqué que d’effectuer un clic droit dans votre navigateur de fichiers graphique ! La création d’un répertoire se fait avec la commande mkdir (make directory), suivie du nom du répertoire à créer. Le répertoire est alors crée dans le répertoire courant :

~$ mkdir Dossier

Pour créer un répertoire et se sous-répertoires simultanément, on ajoute l’option -p :

~$ mkdir -p Dossier/SousDossier1/sousdossier2

4

La suppression d’un répertoire vide s’effectue avec la commande rmdir (remove directory). Si le répertoire n’est pas vide, le système refuse de vous obéir :

~$ rmdir tests/

5

L’option -p permet de supprimer le répertoire ciblé, ainsi que son (ou ses) répertoire(s) parent(s). Ainsi, la commande :

~$ rmdir -p Dossier/tests

6

va supprimer non seulement le répertoire tests/ mais aussi le répertoire Dossier/ par la même occasion.

À savoir que la commande rm, qui permet de supprimer des fichiers (comme nous allons le voir ci-après), utilisée avec l’option -r permet également de supprimer un répertoire et son contenu de façon récursive, autrement dit la suppression concerne également les sous-répertoires :

~$ rm -r tmp/

Et si vous ajoutez l’option -f, les fichiers protégés en écriture seront également supprimés, sans vous demander la moindre confirmation :

~$ rm -rf tmp/

7.jpg
(ne tapé cette commande sous aucun prétexte !!! À utiliser avec précautions !)

03 ► JONGLER AVEC SES FICHIERS :

03.1 ) Créer, déplacer et supprimer des fichiers.

La copie des fichiers s’effectue via la commande cp (copy). On l’utilise en respectant la syntaxe suivante :

~$ cp <fichier(s)_à_copier> <répertoire_de_destination>

Par exemple :

~$ cp photo1.jpg photo2.jpg photo3.jpg mes_images/

8

Remarquez au passage que nous pourrions ici simplifier la commande en utilisant un métacaractères comme évoqués dans l’article précédent. En effet, si nous souhaitons copier l’ensemble des fichiers d’extension .jpg, nous pourrions écrire :

~$ cp *.jpg mes_images/

9

Rappelons que le caractère * remplace zéro, un ou plusieurs caractère(s).

Par ailleurs, il est possible de copier tout un répertoire de façon récursive en ajoutant l’option -r :

~$ cp -r <répertoire(s)_à_copier> <répertoire_de_destination>

Le déplacement de fichiers et de répertoires s’effectue avec la commande mv (move) :

~$ mv <fichier/répertoire_à_déplacer> <répertoire_de_destination>

mv peut également être utilisé pour renommer un fichier ; dans ce cas, elle prend en paramètre le nom du fichier en question, suivi de son nouveau nom :

~$ mv document.txt contrat.txt

10

Enfin, pour supprimer un fichier, on utilise la commande rm (remove) suivie du nom du fichier concerné :

~$ rm <fichier_à_supprimer>

Comme on l’a vu plus haut dans le cas des répertoires, l’option -f permet de supprimer les fichiers protégés en écriture sans pour autant avoir à confirmer cette action.

Et pour supprimer tout le contenu d’un répertoire (fichiers et sous-répertoires y compris), on se positionne dans ledit répertoire et on exécute :

~$ rm -rf *

03.2 ) Une alternative à la copie : le lien symbolique.

Pour simplifier la gestion des fichiers, il peut parfois s’avérer utile de créer ce que l’on appelle un lien symbolique. Un lien symbolique contient le nom d’un fichier, ou plus exactement, le chemin vers ce fichier. Il joue ainsi le rôle de pointeur vers ce dernier.

Vous l’aurez compris, la création d’un lien permet d’éviter la copie physique d’un fichier si l’on souhaite en disposer à plusieurs endroit de l’arborescence .

symlink_concept

Pour créer un lien, on utilise la commande ln ; l’option -s permet d’indiquer qu’il s’agit d’un lien symbolique. La syntaxe est la suivante :

~$ ln -s

Notez que lors de la création d’un lien symbolique, l’existence du fichier lié n’est pas vérifiée, c’est donc à vous d’être vigilant sur ce point ; s’il n’existe pas, le lien ne fonctionnera pas, tout simplement.

Considérons un exemple concret : après avoir téléchargé, puis lancé le fichier binaire (l’exécutable) d’un quelconque logiciel, vous constatez que le processus d’installation automatiquement a positionné l’exécutable exec dans le répertoire /opt/Editeur/Nom/bin/exec .Ce qui n’est guère pratique pour l’utiliser, car ce chemin n’étant pas défini dans la variable $PATH, il faudra systématiquement spécifier tout son chemin d’accès pour l’utiliser …

Nous allons donc créer un lien symbolique vers le fichier exécutable qui nous intéresse (il s’agit d’un script Bash nommé « auto-pass-generate.sh« , qui génère des mots de passe aléatoire de la taille et difficulté que vous voulez) que « j’ai crée ». Au passage, je pense d’ailleurs que la création de script Bash (.sh) ça sera la prochaine aventure que je vous ferais suivre après avoir fini avec le sujet « la ligne de commande ») … Oula ! Ça fait un peu-beaucoup de parenthèse tout ça. Je reprend :

Nous allons donc créer un lien symbolique vers le fichier exécutable qui nous intéresse dans un répertoire qui lui, est défini dans $PATH :

~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin/:/usr/bin/:/bin/sbin/:/sbin/bin/
~$ ln -s /opt/Editeur/Nom/bin/exec /usr/local/bin/exec
~$ ls -l /usr/local/bin/*.sh

11

À présent, il est possible maintenant de lancer la commande exec (auto-pass-generate.sh) depuis n’importe quel endroit de l’arborescence de fichiers ; le système saura retrouver le fichier exécutable correspondant grâce à la création du lien symbolique précédent.

(bon, après c’est vrai qu’il est possible de faire ça de manière plus simple en copiant n’importe quel exécutable pris en charge par votre terminal dans le répertoire /bin . Mais il reste important de connaître et de maitriser la création de lien symbolique).

04 ► LIRE OU ÉTUDIER LE CONTENU D’UN FICHIER :

Pour simplement visualiser le contenu d’un fichier (sans possibilité d’édition, trois commandes sont à retenir : cat, more et less .Il suffit de les faire suivre du nom (ou du chemin) du fichier qui vous intéresse .

-> cat affiche tout le contenu du fichier dans le terminal et vous rend la main immédiatement ;

-> more permet de visualiser le contenu du fichier page-par-page ; on passe d’une page à l’autre à l’aide de la touche [Espace] ;

-> less, à la différence de more, ne charge pas le fichier dans son intégralité avant de commencer à l’afficher ; c’est pourquoi il est préférable d’utiliser less plutôt que more dans le cas de gros fichiers.

Si seul le début ou la fin d’un fichier vous intéresse, vous pouvez utiliser les commandes suivantes :

~# head /var/log/messages

(affiche les 10 premières lignes du fichier /var/log/messages )

~# tail /var/log/messages

(affiche les 10 dernières lignes du fichier /var/log/messages)

Dans les deux cas, on peut utiliser l’option -n pour définir un nombre de ligne différent de 10 :

~# tail -n 30 /var/log/messages

Très utile également, l’option -f (follow) qui permet de passer en mode « attente » :

~# tail -f /var/log/messages

Les 10 dernières lignes du fichiers sont affichées, puis dès qu’une nouvelle donnée est inscrite dans le fichier, elle est retranscrite immédiatement à l’écran. Le raccourci [Crtl]+[C] permet de quitter ce mode et de reprendre la main.

La commande nl permet d’afficher le contenu du fichier passé en argument en ajoutant la numérotation des lignes. Pour spécifier un séparateur d’affichage entre le numéro de la ligne et la ligne elle-même, il est possible d’utiliser l’option -s, suivie du caractère séparateur entre guillemets, comme suit :

~# nl -s « : » /var/log/messages | tail
6584:Feb     5 ….
[…]
…………..
……………………..
[…]

La commande file permet de lire le début d’un fichier pour en déterminer le type de contenu ; elle nécessite bien entendu d’avoir le droit de lecture sur le fichier concerné. Exemples :

~$ file fichiers_video.avi
fichiers_video.avi : RIFF …….
[….]

~$ file un_document
un_document :  ASCII text, with very long lines

Pour la comparaison de fichiers, on retiendra les commandes cmp, et diff. La commande cmp permet de comparer le contenu de deux fichiers en précisant la position de la première différence relevée :

~$ cmp fichier.txt fichier2.txt
fichiers1.txt fichier2.txt sont différents :  octet 14, ligne 3

Comme vous vous en doutez, si la commande ne retourne rien, c’est que les deux fichiers sont rigoureusement identiques.

La commande diff, de son coté, permet de comparer le contenu de deux fichiers ou répertoires et dresse la liste de toutes les différences relevées.

Dans un autre registre, la commande touch permet de modifier la date d’accès et la date de modification de chaque fichier passé en argument.

Par défaut, ces horodatages sont remplacés par la date et l’heure courantes, mais l’option -t suivie d’une date au format MMJJhhmm (mois, jour, heures, minutes) permet d’utiliser cette dernière à la place de la date courante :

~$ ls -l
-rw-r–r–   1   user  user    1038819     5 nov.   16:36  mycapture

~$ touch -t 02162340 mycapture && ls -l
-rw-r–r–   1   user  user    1038819     16 feb.    23:40  mycapture

Toutes ces commandes constituent déjà un bel éventail de base pour vous entrainer à la ligne de commandes. Créez, déplacez, renommez, supprimez !
N’hésitez pas à faire un maximum de tests jusqu’à ce que vous vous sentiez aussi à l’aise qu’en utilisant votre interfac graphique. Bientôt, celle-ci ne sera plus qu’un souvenir lointain tellement vous trouverez votre terminal bien plus rapide.
Et là, vous vous direz, « mais pourquoi ai-je tant attendu ?! » 🙂

Screenshot-bin-bash1.png

► Préparez vous bien en tout cas car dans le 4ème article, nous parlerons,créerons et exécuterons des « scripts shell« .

Je vous dit à très vite alors ….

logo_gnu_linux_pratique.jpg

Kali Linux 2016.2 – add-apt-repository

Bonjour à vous utilisateurs de Kali Linux et aux curieux.

Si comme moi, vous vous êtes intéressés à la nouvelle de Kali, vous avez sans doute dû vous retrouvez face à un problème lorsqu’il fallu ajouter une clé référentiels PPA afin d’ajouter un logiciel spécifique à votre dépôt.

ajouter_ppa

clé référentiels PPA :

Une archive de paquetages personnels (PPA) est un référentiel de logiciel spécial afin de pouvoir télécharger des source de paquets à construire pour ensuite les publier en tant que dépôt APT par Launchpad ou une application similaire.

Alors que le terme est utilisé exclusivement dans Ubuntu, Launchpad hôte Canonical envisage l’adoption au-delà de la communauté Ubuntu.

Debian permet aux utilisateurs d’ajouter et d’utiliser des référentiels PPA par une application nommée add-apt-repository. Toutefois, Kali Linux ne l’a pas inclus dans sa liste de paquets par défaut, car il s’agit d’une application spéciale et certaines modifications ont été faites pour le faire fonctionner pour ce qu’il fait le mieux (test de pénétration), il y’a une chance que, en ajoutant des dépôts PPA non testés et non pris en charge et l’application, vous risquez de briser votre installation.

Cependant, PPA est un outil puissant à avoir et un grand nombre des applications spécifiques qui ne sont pas disponibles dans les dépôts sont disponibles via les dépôts PPA.Les utilisateurs devraient prendre des précautions supplémentaires avant d’ajouter des dépôts inconnus et aléatoires car il pourrait très bien casser d’autres choses. Je veux dire, comment savez-vous que le propriétaire PPA n’a pas ajouté un code nuisible dans son application ? Généralement, vous ne pouvez pas le savoir. Du coup, comment sauriez-vous que votre Kernel n’a pas attrapé un spyware qui espionnerez votre activité ? Vous deviendrez alors l’arroseur arroser …. Mais bon, nous pourrions partir encore plus loin dans ce sens et ce n’est pas ce qui nous intéresse dans cet article qui est, l’ajout de l’outil « add-apt-repository dans Kali Linux 2016.2 ».

Commençons.

01 ► Installations des paquets Python nécessaires :

~# apt-get install python-software-properties

1

02 ► Installation des paquets manquants à l’utilitaire « apt » :

~# apt-get install apt-file

2

03 ► Mise à jour des paquets « apt » :

~# apt-file update

3
(comme vous pouvez le remarquer sur l’image, malheureusement, beaucoup de clés PPA réserver à la distribution Ubuntu, ne seront pas valides pour Kali.)

04 ► Vérifions maintenant si l’utilitaire « add-apt-repository » est bien présent dans notre dépôts afin d’être pris en charge par notre noyau si il viendrait à être lancé sur notre système :

~# apt-file search add-apt-repository

3-1
(c’est bien le cas)

05 ►Nous allons maintenant créer le script Bash « add-apt-repository » manuellement :
(je tiens à dire que le script n’est pas de moi. À ce jour, je vous l’avoue, je serais incapable de créer un tel script. Merci donc à l’équipe Kali Linux.)

Création du script :
~# nano add-apt-repository

Copiez-y ceci :

#!/bin/bash
if [ $# -eq 1 ]
NM=`uname -a && date`
NAME=`echo $NM | md5sum | cut -f1 -d" "`
then
  ppa_name=`echo "$1" | cut -d":" -f2 -s`
  if [ -z "$ppa_name" ]
  then
    echo "PPA name not found"
    echo "Utility to add PPA repositories in your debian machine"
    echo "$0 ppa:user/ppa-name"
  else
    echo "$ppa_name"
    echo "deb http://ppa.launchpad.net/$ppa_name/ubuntu oneiric main" >> /etc/apt/sources.list
    apt-get update >> /dev/null 2> /tmp/${NAME}_apt_add_key.txt
    key=`cat /tmp/${NAME}_apt_add_key.txt | cut -d":" -f6 | cut -d" " -f3`
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys $key
    rm -rf /tmp/${NAME}_apt_add_key.txt
  fi
else
  echo "Utility to add PPA repositories in your debian machine"
  echo "$0 ppa:user/ppa-name"
fi

3-24(le script, sur le blog, à vue d’œil n’est pas complet mais si vous le sélectionnez en entier, vous l’aurez en entier. Petit beug de WordPress… désolé.)

06 ►Rendons maintenant le script exécutable et utilisables par l’utilisateur root :

~# chmod o+x add-apt-repository
~# chown root:root add-apt-repository5-107 ►C’est le moment de tester le script :

~# ./add-apt-repository ppa:noobslab/themes6
(c’est bon, il fonctionne…)

08 ►Dernière étape maintenant. Nous allons le copier dans le répertoire /bin, de façon à le rendre exécutable comme n’importe quelles autres commandes du système :

~#
cp add-apt-repository /usr/bin
Testons :
~# add-apt[Tab]910
(parfait !)Et voilà le travail .
À bientôt ……

[2] Ligne de commandes – Comprendre.

À découvrir dans cette deuxième parties ….

Les fonctionnalités qui simplifient la vie :
Maintenant que vous êtes familiarisé avec l’outil, voyons comment profiter des fonctionnalités avancées du shell pour accroître l’ergonomie de votre terminal et surtout, gagner en rapidité. Au programme : auto-complétion des commandes, gestion de l’historique et raccourcis clavier.

Le contexte : quelques concepts de base :
Le shell est principalement destiné à l’exécution de programme. C’est tout un environnement d’exécution qui est ainsi mis en place dès votre connexion, environnement que nous allons explorer dans cet article. Nous allons également apprendre à manipuler les programmes qui tournent en arrière-plan une fois exécutés dans le shell.

Des caractères très spéciaux :
Outre une syntaxe spécifique, composée d’options et/ou de paramètres divers, il faut parfois employer des caractères spéciaux, qui permettent, selon le cas, de rediriger le résultat d’une commande ailleurs que vers votre écran, de combiner plusieurs commandes, ou encore de désigner tout un ensemble de fichiers cibles par exemple.

01 ► LES FONCTIONNALITÉS QUI SIMPLIFIENT LA VIE .

Oui, le shell, quel qu’il soit, est plutôt bien conçu. Il intègre des fonctionnalités avancées, notamment au niveau de la saisie des commandes, qui facilitent les choses et qui permettent de gagner en rapidité. Voyons de quoi il s’agit ….

01.1 ► La complétion automatique :

Le shell Bash propose de compléter automatiquement les commandes que vous saisissez. Comment ? Eh bien vous commencer à taper les premières lettres d’une commande ou bien du nom d’un fichier ou d’un répertoire et vous appuyez sur la touche [Tab] (tabulation). Le shell complète alors automatiquement votre saisie s’il n’y a qu’une possibilité, ou affiche la liste des possibilités s’il y en a plusieurs (et dans ce cas, il faudra appuyer 2 fois sur la touche tabulation).

~$ cd a [Tab]

1

Si vous obtenez un « bip » pour tout résultat, c’est qu’aucun fichier ou répertoire commençant par les caractères saisis n’existe dans le répertoire courant (là où vous vous trouvez) ; dans le cas d’un nom de commande, cela signifie soit que la commande n’existe pas, soit que la commande n’existe pas, soit que vous tentez d’exécuter une commande qui nécessite les droits d’administrateur du système (exemple : ifconfig depuis peu de temps), alors que vous êtes connecté en tant que simple utilisateur.

Comprenez que ce mécanisme d’auto-complétion est une fonctionnalité vraiment pratique, qui permet d’une part de gagner en rapidité et d’autre part, d’éviter les fautes de frappe et d’exécuter une commande qui ne peut fonctionner.

La fonctionnalité d’auto-complétion de votre shell est possible grâce à cette instruction contenue dans le fichier de configuration de Bash, à savoir le fichier /home/user/.bashrc :

if  [  -f  /etc/bash_completion  ]; then
         . /etc/bash_completion
fi

2-auto-completion

Le fichier /etc/bash_completion mentionné ici est fourni par le paquet bash-completion ; il comporte l’ensemble des règles d’auto-complétion et c’est grâce à lui que vous pouvez compléter un nom de commande, de fichier, ect. Le répertoire /etc/bash_completion.d/ comporte lui aussi des règles d’auto-complétion, plus complexes, propres à certaines commandes (apt-file.debconf.deborphan.git.grub, ect).

Comme vous le devinez, il est possible de créer ses propres règles d’auto-complétion et de les ajouter au fichier /etc/bash_completion ou dans le répertoire /etc/bash_completion.d/. Toutefois, ceci dépasse quelque peu le cadre de notre article.

2-1

01.2 ► Gagnez du temps grâce à l’historique des commandes :

Le shell a très bonne mémoire ! Il conserve toutes les commandes que vous avez saisies dans un fichier. L’historique des commandes, stocké dans votre répertoire personnel ; il s’agit du fichier /home/user/.bash_history. Ceci permet de rappeler rapidement une commande déjà saisie précédemment.

La commande history permet de lister tout l’historique ; les commandes sont identifiées chacune par un numéro :

~$ history
[…]
……..
………..
[…]

2-3-history

Lorsque vous êtes dans le terminal, un simple appuie sur la touche [] suffit à rappeler la commande précédemment saisie ; un double point d’exclamation  [!!] permet de faire de même. La navigation dans l’historique s’effectue avec les touches [] et [].

Pour rappeler une commande rapidement à partir de son numéro, vous pouvez également saisir :

~$ !n

2-3-1

où n est le numéro de la commande en question. Et pour rappeler la dernière commande commençant par un motif en particulier, on sasira !, par exemple :

~$ !cp

2-3-2

Ici, c’est la dernière copie effectuée (commande cp) qui sera rappelée.

Notez que par défaut, 500 entrées sont conservées dans l’historique, mais vous pouvez modifier cette valeur en éditant et en modifiant le fichier /home/user/.bashrc dans lequel vous trouverez plusieurs variables associées à l’historique des commandes. En voici une sélection :

► Pour éviter qu’une commande identique à la dernière commande ne soit conservée dans l’historique :

export HISTCONTROL=ignoredups

► Pour ne pas enregistrer les commandes par le caractère espace :

export HISTCONTROL=ignorespace

► Pour « mixer » les deux options précédentes :

export HISTCONTROL=ignoreboth

► Pour ajouter la date et l’heure devant chaque commande de l’historique :

export HISTTIMEFORMAT= »%D %H:%M « 

► Pour définir le nombre maximum d’entrées dans l’historique (500 par défaut) :

export HISTFILESIZE=800

► Pour définir une liste de commandes qui seront automatiquement exclues de l’historique :

export HISTIGNORE= »ls:cd:ll:la:exit »

On notera également dans le fichier /home/user/.bashrc la présence de l’option :

shopt -s histappend

Elle permet de regrouper les historiques au travers des sessions (les nouvelles lignes sont ajoutées au fichier, le contenu n’est donc pas écrasé à chaque session).

01.4 ► Les alias des commandes :

Les alias sont des raccourcis équivalents à des commandes. En général, on crée des allias pour les commandes que l’on utilise fréquemment, de manière à bénéficier d’une saisie plus rapide.

De tels raccourcis sont crées très simplement, à l’aide de la commande alias. Un certain nombre d’alias existent par défaut sur votre système. Pour crée un nouvel alias, on lance la commande en respectant la syntaxe suivante :

alias =’<commande_à_remplacer>

Par exemple, saisissez dans le terminal :

~$ alias la=’ls -la’

3.jpg

Suite à cela, plutôt que de taper ls -la, vous n’aurez plus qu’à saisir la . La commande ls -la liste le contenue du répertoire courant (ls), de façon détaillée (-l) en incluant les fichiers et répertoires cachés (-a).

Toutefois, notez bien que définir un alias de cette façon ne permet pas de conserver le raccourci de façon définitive. en effet, vous ne pourrez plus l’utiliser dès que vous fermerez votre terminal.

Pour que l’alias soit utilisable en permanence, il est nécessaire de le déclarer dans votre fichier .bashrc, dans la section adéquate, via l’éditeur de votre choix :

# Mes alias
alias ll=’ls -l’
alias la=’ls -A’
alias l=’ls -CF’
alias cdd=’cd ..’

3-1-alias
Il se peut d’ailleurs que le fichier comporte déjà par défaut certains alias. Par exemple ici, la commande ls -l (liste détaillée) devient tout simplement ll, qui est bien plus simple à taper !

Pour ajouter un nouvel alias, on ajoutera simplement une ligne du type :

alias <commande_à_remplacer>=’

Notez qu’il faudra redémarrer votre terminal pour que votre alias soit pris en compte.

Par ailleurs, vous remarquerez peut être que votre fichier .bashrc comporte également les instructions suivantes (ou quelque chose d’approchant) :

alias ls=‘ls –color=auto’
alias grep=‘grep –color=auto’
alias fgrep=‘fregp –color=auto’
alias egrep=‘egrep –color=auto’

Ceci permet d’obtenir la coloration syntaxique pour les commandes correspondantes. Ainsi, en faisant un ls sur un répertoire par exemple, chaque élément de la liste sera colorisé selon le type (répertoire, archive, fichier audio, image, ect).

Pour visualiser l’ensemble des alias définis, tapez simplement alias dans votre terminal :

~# alias
[…]
………
……….
[…]

3-2

Et pour visualiser un alias en particulier, on fera suivre la commande alias du nom du raccourci en question, comme dans cet exemple :

~# alias la
alias la=’ls -A’

3-3

Si l’un des alias définis n’est plus souhaité, vous pouvez supprimez la ligne correspondante dans le fichier .bashrc, ou simplement la commenter (en ajoutant le caractère dièse # en début de ligne) :

# mes alias
alias ll=’ls -l’
#alias la=’ls -A’
alias l=’ls -CF’

Ici encore, il vous faudra fermer puis rouvrir le terminal pour que vos modifications soient pris en compte.

Vous pouvez également supprimer momentanément un alias (autrement dit, tant que vous ne fermez pas le terminal) en utilisant la commande unalias suivie du raccourci à supprimer, comme suit :

~$ unalias ll

01.5 Les raccourcis qui simplifient la vie :

Pour finir, sachez que l’utilisation du shell peut être simplifiée grâce à un ensemble de raccourcis clavier qu’il est utile de connaître :
(je vous les mets car ce sont ceux par défaut mais sachez que vous pouvez les personnaliser)

[Crtl] + [P] ou [↑] = Rappelle la commande précédente
[Crtl] + [N] ou [↓] = Rappelle la commande suivante
[Crtl] + [A] ou [Home] = Va en début de ligne
[Crtl] + [E] ou [Fin] = Va en fin de ligne
[Crtl] + [D] ou [Suppr] = Supprime le caractère qui se trouve sous le curseur
[Crtl] + [K] = Supprime tout ce qui se trouve à droite du curseur
[Crtl] + [U] = Supprime tout ce qui se trouve à gauche du curseur
[Crtl] + [L] = Efface l’écran
[Crtl] + [R] = Lance une recherche dans l’historique ; on saisit un motif et la plus récente commande qui le contient apparait (une succession de [Crtl] + [R] permet de remonter dans l’historique).
[Crtl] + [D] = Ferme la session Bash (lorsque ce raccourci est saisi sur une ligne vide) ; il est également possible de fermer une session Bash avec la commande exit, suivie de la touche [Entrée].

Voilà pour les quelques fonctionnalités qui rendent la ligne de commandes encore plus pratique ! Vous devez d’ores et déjà commencer à vous sentir plus à l’aise face à cet écran noir . 🙂

02 ► LE CONTEXTE : QUELQUES CONCEPTS DE BASE .

Avant d’aller plus loin, outre la possibilité de naviguer aisément dans votre fichier, n’oublions pas que le shell est principalement destiné à vous permettre d’exécuter des programmes. Pour ce faire, tout un environnement d’exécution est mis en place dès votre connexion et vous pourrez même vous amuser à « jongler » avec les différents programmes.

02.1 ► Commandes internes et externes :

On distingue deux types de commandes acceptés par le shell :

-> Les commandes dites internes sont des commandes dont le code est implanté au sein même du shell, autrement dit c’est le shell lui-même qui exécute l’action ; aucun processus supplémentaire n’est crée pour l’exécution de ces commandes. Ces commandes concernent généralement la modification de l’environnement courant (cd, pwd, type, ect).

-> Les commandes dites externes sont des commandes dont le code est situé dans un fichier exécutable, stocké dans le système de fichiers (ls, cp, mv, ect). Ainsi, lorsque vous saisissez la commande ls dans le terminal, le shell demande au noyau de charger le fichier /usr/bin/ls ; un nouveau processus est donc crée. Naturellement, le shell doit connaître l’emplacement du code d’une commande externe pour pouvoir l’exécuter. Pour cela, il utilise la variable PATH, qui contient la liste des répertoires où sont localisés les exécutables (voir le prochain chapitre).

Pour déterminer si une commande est interne ou externe, on utilise la commande interne type :

~$ type pwd
pwd est une primitive du shell
~$ type mv
mv est /usr/bin/mv

4
Certaines commandes peuvent même être implémentées à la fois en tant que commande interne et en tant que commande externe !

02.1 ► Les variables d’environnement :

Comme nous l’avons spécifié brièvement dans le premier article (introduction), dès votre connexion au système, le shell met à votre disposition des variables spécifiques, appelées « variables d’environnement » qui permettent de communiquer le contexte d’exécution à toute commande que vous lancerez dans le terminal. Elles contiennent en quelque sorte des informations de base, dont le shell a besoin pour fonctionner.

02.2 ► Afficher le contenu des variables :

Pour afficher la liste des variables d’environnement ainsi définies, on utilise simplement la commande set :

~$ set
BASH =/bin/bash
………..
…….
[…..]

Par défaut, les variables définies au niveau du shell ne sont pas transmises  aux commandes lancées à partir de celui-ci : le shell doit d’abord les exporter. Toutefois, certaines variables sont exportés par défaut ; pour en visualiser la liste, on utilise la commande env ou printenv :

~$ env
LS_COLORS=rs …..
……
[….]

5

La commande locale permet quant à elle de visualiser les variables concernant la langue  et l’encodage utilisés pendant la session :

~$ locale
LANG=en_IN
……
………
[….]

6.jpg

Un certain nombres de variables prédéfinies joue un rôle essentiel pour l’utilisateur. Leur valeur peut être des l’installation du système, ou être initialisée à tout moment par l’utilisateur.

Parmi les variables d’environnement à connaître :
-> HOME : qui désigne l’emplacement du répertoire personnel de l’utilisateur.
-> LANG : qui est utilisée par les différents programmes pour déterminer la langue des messages à afficher.
-> LOGNAME : qui désigne le nom de l’utilisateur.
-> OLDPWD : qui désigne le chemin vers le répertoire courant (on y accède via la commande cd ~)
-> PATH : est une variable très importante, car elle renferme tous les chemins d’accès aux fichiers exécutables du système ; ainsi, les commandes dont le chemin d’accès est spécifiée dans la variable PATH peuvent être lancées depuis n’importe quel endroit de l’arborescence de fichiers, sans mentionner leur chemin complet.
(cd, tail, apt-get, ect).
-> PS1 : désigne le prompt principal (par défaut $).
-> PS2 : désigne le prompt secondaire, qui apparait au début de la ligne lorsqu’une commande n’est pas terminée et que l’utilisateur doit continuer sur la ligne suivante (par défaut, il est représenté par le caractère > ).
-> PWD : désigne le chemin vers le répertoire courant .
-> TERM désigne le type de terminal utilisé ; cette variable doit se trouver dans l’environnement, car elle est utilisée par de nombreuses commandes faisant appel aux caractéristiques d’affichage (vi, more, clear, ect).

Pour afficher le contenu d’une variable (sa valeur), on utilise le caractère $. Par exemple, pour visualiser le contenu de la variable PATH, il faut saisir la commande :

~$ echo PATH
/usr/local/sbin :/usr/local/bin :/usr/sbin :/usr/sbin :/sbin/ :/bin/

7

Si la commande ne retourne rien, c’est que la variable n’est pas encore définie.

02.3 ► Modifier la valeur d’une variable d’environnement :

La valeur d’une variable peut être modifiée à tout moment. Pour affecter une nouvelle valeur à une variable d’environnement, on utilise le caractère = ; si la variable n’existe pas encore, elle est crée par la même occasion.

~$ var1=foo
~$ env | grep var
var1=foo

Si la variable ne se trouve pas encore dans l’environnement, on l’y exportera via la commande export :

~$ export var1=bar
~$ env | grep var
var1=bar

Considérons un exemple concret. Comme nous l’avons vu au paragraphe précédent, la variable d’environnement PATH contient une liste de répertoires qui sont explorés par le shell lorsqu’une commande externe est lancée :

~$ echo $PATH
[……]

Les répertoires sont explorés dans l’ordre dans lequel ils sont affichés.

Il arrive que l’ont ait besoin d’ajouter un nouveau chemin à cette variable PATH, par exemple lorsque l’on vient d’installer un nouveau logiciel dans un répertoire « exotique » et que l’on souhaite le lancer en en tapant simplement le nom de l’exécutable correspondant. Pour que ce nouveau chemin apparaisse en dernière position dans la liste du PATH (il sera alors exploré en dernier) :

~$ export PATH=$PATH:/chemin/vers/exécutable

Pour qu’il soit exploré en premier, on saisira en revanche :

~$ export PATH=/chemin/vers/écutable:$PATH

Si vous procédez ainsi, cette modification ne sera effective que pour la session en cours et la valeur de PATH sera réinitialisée dès la prochaine session shell. Comme d’habitude, pour modifier la variable PATH de façon permanente, on ajoute la ligne suivante dans le fichier .bashrc :

export PATH=$PATH:/chemin/vers/exécutable

À noter pour finir l’existence de la variable CDPATH qui permet, à l’instar de PATH, de définir une liste de répertoires, où la commande cd doit rechercher le répertoire dont vous saisissez le nom.

Ainsi, en adaptant sa valeur à vos besoins spécifiques, vous pourrez gagner beaucoup de temps lorsque vous naviguerez dans votre système de fichiers, car vous ne serez pas obligé de saisir le chemin complet vers les répertoires que vous utilisez couramment. Par exemple (toujours dans le fichier .bashrc) :

export CDPATH=:.:/home/user/documents/importants/

Imaginons que le répertoire /home/user/documents/importants/ contienne un répertoire factures/ . Alors la commande sera :

~$ cd factures/

exécutée depuis n’importe quel endroit du système de fichiers vous permettra d’accéder audit répertoire.

03 ► LA GESTION DES PROCESSUS .

Dans le premier article (introduction), nous avons rapidement évoqué le fait de pouvoir lancer une application directement à partir de son fichier exécutable, accompagnée du caractère & pour « récupérer la main » sur le terminal.
Ce qui nous donne comme exemple :

~$ algobox &
[1] 1487

8

Mais que signifient ces nombres que le shell nous retourne en échange ?

03.1 ► Les jobs :

L’exécution en arrière plan, initiée via l’utilisation du caractère & , permet à un utilisateur de lancer une commande et de récupérer immédiatement la main sur votre terminal.

Le système Unix attribue un numéro à chaque processus, appelé « identifiant »  du processus (ou PID) , dès leur création. Dans notre exemple, 1487 est l’identifiant du processus de l’application AlgoBox (que je vous conseille au passage). Le [1] correspond quant à lui à un numéro de job, attribué par le shell. Le shell Bash permet en effet de suspendre, reprendre ou passer en arrière-plan un processus, ce qui nécessite une identification supplémentaire en sus de l’identifiant attribué par le système.

Ainsi, si vous lancez d’autres jobs en arrière plan alors que le premier est toujours en cours d’exécution, le shell leur attribuera les numéros 2, 3, 4, ect.

~$ algobox &
[1] 1487
~$ scratch &
[2] 120836

Lorsque les jobs d’arrière plan se terminent, si vous fermez l’application correspondante, vous obtenez en retour :

[1] – Fini       algobox
[2] + Fini      scratch

Le signe + permet d’identifier le dernier processus à avoir été lancé dans le terminal ; ce sera le job considéré par défaut lorsque vous effectuerez les manipulations suivantes .

03.2 ► Manipuler les processus :

À quoi sert de connaître les identifiants de processus ou les numéros de jobs ?

Commençons par les numéros de jobs. Lorsqu’un job est lancé en arrière-plan, vous pouvez le laisser s’exécuter jusqu’à la fin, le ramener au premier plan ou bien alors lui envoyer un message, que l’on appellera « signal« .

Pour ramener un job au premier plan, on utilise la commande fg (pour foreground). Si un seul job s’exécute en arrière plan, fg peut être utilisée sans arguments ; en revanche, si plusieurs sont en cours d’exécution, le shell sélectionnera le dernier job lancé en arrière plan, à moins de préciser en argument le numéro du job souhaité (précédé du caractère %)
Exemple :

~$ cheese &
[1] 3804
~$ orage &
[2] 3846
~$ fg %1
cheese

Le job reprend alors le contrôle du terminal, autrement dit son comportement est tel que si vous n’aviez pas utilisé de &.

Inversement, la commande bg (pour background), permet d’envoyer un job en arrière plan.
Exemple :

~$ fg %1
cheese
^Z
[1]+    Stoppé           cheese
~$ bg %1
[1]+  cheese &

Ici nous reprenons donc la main et le processus cheese continue de s’exécuter en arrière-plan. Notez bien l’utilisation de la combinaison de touches [Crtl]+[Z] qui permet de suspendre un processus (pour le reprendre ultérieurement).

Pour visualiser les numéros de chaque job en cours d’exécution, on utilise la commande jobs, éventuellement accompagnée de l’option -l qui affiche en plus le PID.

~$ jobs -l
[1]-     3804    En cours d’exécution     cheese &
[2]+    3846    En cours d’exécution      orage &

L’envoi d’un signal permet de positionner un processus dans un état déterminé (gelé,actif), voire de le tuer complétement. La commande kill permet d’envoyer un signal à un processus ; elle nécessite de connaître le PID du processus en question, PID que nous pouvons retrouver grâce à la commande ps. Celle-ci permet de lister l’ensemble des processus en cours d’exécution sur le système à un instant donné ; la commande top, quant à elle, en donne un aperçu en temps réel.

~$ ps -ef

9-ps
Les options -e et -f permettent respectivement de lister l’ensemble des processus et afficher un maximum d’informations.

Les principaux signaux qui peuvent être envoyées aux processus sont les suivants :

-> 1, SIGHUP (hangup) : les fichiers de configuration du processus sont rechargés.
-> 9, SIGKILL (tuer) : le processus est brutalement tué par le système ; cela peut s’avérer utile lorsque le processus est devenu incontrôlable.
-> 15, SIGTERM (équivalent à [Crtl]+[C]): le processus se termine « proprement » en sauvegardant des fichiers si nécessaire.
19, SIGSTOP (équivalent à [Crtl]+[Z]) : on suspend l’exécution du processus.

La liste complète des signaux est donné par la commande kill -l .

10-kill

Finalement, pour envoyer le signal SIGTERM à notre processus bleachbit, de PID 482, nous exécutons la commande :

~$ kill -s 15 482

11

L’option -s est suivie au choix du numéro ou du nom du signal. Si aucun signal n’est précisé dans la commande, c’est TERM qui est envoyé par défaut.

Et c’est sur cet acte de barbare que se termine la deuxième partie de cet article. Les variables d’environnement de votre shell n’ont plus de secret pour vous, et la manipulation des processus est désormais un véritable jeu d’enfant…. Non ? Dans ce cas, ce n’est qu’une question de temps, car une pratique régulière vous permettra de maîtriser les quelques notions abordées ici.

04 ► DES CARACTÈRES TRÈS SPÉCIAUX …..

Bientôt  , nous allons découvrir ensemble les premières commandes de base. Mais avant, il nous reste une dernière chose à aborder pour s’approprier tous les rudiments du langage  shell : la syntaxe nécessite parfois l’utilisation de caractères spéciaux, qu’il est indispensable de connaître pour bien formuler ses requêtes.

linuxfrench-3

01 ► La signalisation :

1.1 ) Les opérateurs de redirection.

« Redirection » ? Je ne savais pas que je suivais une direction ….Eh oui, il faut savoir que par défaut, le résultat d’une commande est dirigée vers la sortie standard du système, à savoir votre écran. Vous vous doutez bien sûr, que s’il y une sortie…c’est qu’il y a aussi une entrée standard ; il s’agit par défaut de votre clavier (via lequel vous saisissez les commandes).

Ainsi, en toute logique, on utilise les redirections lorsque l’on ne souhaite pas que le retour d’une commande aille directement vers la sortie standard. On peut par exemple envoyer le résultat d’une commande dans un fichier tiers, vers une imprimante ou tout autre périphérique, ou bien utiliser ce résultat en tant que paramètre d’une nouvelle commande.

Et vice-versa, on peut également avoir besoin de remplacer l’entrée standard (la saisie au clavier) par le contenu d’un fichier.

Étudions à présent les différents symboles qui permettent d’effectuer des redirections, en considérant quelques exemples simples :

~$ ls > fichier.txt

20

Le caractère > permet de rediriger le résultat de la commande dans un fichier. Le résultat de la commande ls, dans ce cas, n’apparaît pas à l’écran. Notez que le contenu du fichier cible est alors effacé avant que le résultat de la commande n’y soit inscrit ; si le fichier cible n’existe pas, il est crée automatiquement.

~$ date >> fichier.txt

21.jpg

Les caractères >> permettent de rediriger le résultat de la commande vers la fin d’un fichier, autrement dit, le contenu – s’il existe – ne sera pas écrasé. On ne fait qu’ajouter un nouveau contenu à la suite du précédent.

~$ make 2> fichier.txt

L’opérateur 2> est particulier, dans le sens où il permet de ne rediriger que les éventuels messages d’erreur, ce qui peur s’avérer utile dans certains cas.

~$ wc < fichier.txt

22

Avec cette syntaxe, la commande prend en paramètre le contenu du fichier :

~$ ps -ef | grep Terminal

23

Le symbole |, appelé pipe (ou tube en français), permet d’utiliser le résultat de la première commande comme entrée standard de la communauté qui suit.

Dans ce dernier exemple, on n’affiche que les processus en cours dont le nom contient le motif « Terminal« . La commande grep permet en effet de filtrer les résultats selon un motif donné, nous y reviendrons plus tard dans un autre chapitre….

Il est bien entendu possible de « cumuler » les opérateurs de redirection si besoin est, comme dans l’exemple suivant :

~$ ps -ef | grep google > proc_google_in_progress

24

1.2 ) Enchaînement de commandes.

Il est possible d’enchaîner plusieurs commandes, en les séparant par un point-virgule (;) : commande1 ; commande2 ; commande3 ; ect. Les commandes sont alors exécutées les unes à la suite des autres.

Dans l’exemple suivant, on crée un répertoire, on y déplace un ensemble de fichiers d’extension .png, puis on se rend dans le répertoire en question :

~$ mkdir images; mv *.png images; cd images; ls

26

Le symbole &, contrairement au point-virgule, permet d’exécuter les commandes simultanément : commande1 & commande2 & commande3 & ect. La première est exécutée en tâche de fond, puis on exécute la deuxième, puis la suivante,ect. Chaque commande exécutée en tâche de fond se voit alors attribuer un numéro (PID comme nous avons ensemble plus haut dans cet article au niveau des processus).

~$ vlc & bleachbit & gedit

1.3 ) Enchaînement conditionnel.

On utilisera l’opérateur OU pour faire en sorte que la deuxième commande ne s’exécute QUE si la première commande ne retourne aucune erreur ou simplement rien. Cet opérateur se traduit par deux pipes :

~$ ps -e | grep schmiblick || echo « c’est quoi ce truc? » c’est quoi ce truc ?

25

On utilisera donc l’opérateur ET pour faire en sorte que la deuxième commande ne s’exécute QUE si la première commande s’est achevée sans erreur. Cet opérateur se traduit par deux & (&&) :

~$ ps -e | grep pulseaudio && echo « le serveur de son est lancé »

27

1.4 ) Substitution de commandes.

La substitution de commandes est aussi une fonctionnalité très pratique. Elle permet de positionner toute une commande – dont on ne connaît pas le résultat – en tant que paramètre d’une autre.

On utilise alors la syntaxe suivante : commande1 $(commande2)

Notons qu’à la place des caractères $() , il est aussi possible d’utiliser des backquotes : commande1 `commande2` .

Voici un exemple concret d’utilisation : on souhaite tuer un processus, ici Gvim (qui est l’utilitaire Vim en GUI = interface graphique), mais on ne connaît pas son PID. De ce fait, nous allons utiliser la commande pidof (très utile) qui permet d’obtenir le PID d’une application recherchée et surtout, de l’appliquer. Par exemple :
(avec une commande « 2 en 1 »)

~$ kill `pidof gvim`

2829

1.5 ) « Protéger » des caractères.

Protéger ? Mais de quoi donc ? Du shell lui-même, tout simplement !

30

Le terme « protection » n’est pas vraiment approprié, on parle en réalité « d’échappement »
de caractère. Cela signifie que l’on fait en sorte que le shell n’interprète pas un caractère donné comme il a l’habitude de le faire. Dans ce cas, on doit précéder ledit caractère d’un anti-slash (\) .

Considérons par exemple le caractère $ dans la commande suivante, qui permet d’afficher à l’écran le contenu de la variable d’environnement $HOME :

~$ echo $HOME

31

Voilà pour son interprétation « normal ». À présent, si on échappe le caractère $, il se comporte comme un simple caractère et le shell l’interprète de façon littérale.
Voyez plutôt :

~$ echo \$HOME

32

De même, si on inscrit la chaîne de caractères entre guillemets simples ...’, elle est interprétée comme du texte :

~$ echo ‘$HOME’

33

02 ► Les expressions régulières.

Une expression régulière est un motif, constitué d’une ou plusieurs caractère(s), qui à lui seul, permet de désigner tout un ensemble de possibilités de complétion.

Les expressions régulières peuvent ainsi être utilisées au sein de nombreuses commandes, pour faciliter les opérations sur les fichiers, notamment lorsqu’il agit de traitement par lots de fichiers.

Par exemple, avec l’éditeur de texte Vim , les expressions régulières peuvent être utiles pour :

-> rechercher un terme : /expression_regulière
-> substituer un terme par un autre : :s/expression_régulière/expression_de_remplacement

On pourra également rechercher au sein d’un fichier les lignes comportant un terme donné grâce au filtre grep :

~$ grep expression_regulière fichier.txt

Pour constituer une expression régulière, on utilise certains caractères spéciaux appelés métacaractères (wild cards ou jokers en anglais) ;

-> le caractère * représente zéro, un ou plusieurs caractère(s).
-> le caractère ? représente un et un seul caractère.

De même, nous venons de voir plus haut que :

-> le caractère \ empêche l’interprétation spéciale d’un métacaractère .
-> les backquotes ` permettent l’interpréter la chaîne qu’ils encadrent comme une commande.
-> les guillemets simples permettent d’interpréter la chaîne qu’ils encadrent comme du texte.

Eux aussi sont considérés comme des métacaractères du shell.
Par ailleurs, il faut savoir que :

-> le caractère ^ désigne le début d’une ligne.
-> le caractère $ désigne la fin d’une ligne.
-> \< ; représente le début d’un mot.
-> \> ; représente la fin d’un mot.

Pour définir des ensembles de possibilités, on utilise les crochets :

-> [liste_de_caractères] ; représente l’un (et un seul) des caractères de la liste.
-> [^liste_de_caractères] ; représente un (et un seul) caractère différent de ceux de la liste.
-> [carac1-carac2] ; représente un (et un seul) caractère compris dans l’intervalle défini entre crochets.

Pour une meilleure compréhension, le tableau ci-après présente quelques exemples d’expressions régulières et leur signification :

Linux$ => la chaîne correspondante (de longueur quelconque) se termine par « Linux ».
La chaîne J’utilise le système d’exploitation GNU/Linux peut correspondre.

^$ => La chaîne correspondante est constituée d’un début de ligne, immédiatement suivi d’une fin de ligne.
Cela correspond donc à une chaîne vide.

^[A-Z][3-6].$ => La chaîne correspondante est composée de trois caractères ; le premier est une lettre majuscule, le deuxième un chiffre compris entre 3 et 6 et le troisième est un caractère quelconque.
Les chaînes F4x, D6_ ou T5% correspondent toutes à cette expression.

[0-9][^A-Z?]$ => La chaîne correspondante (de longueur quelconque) comporte un chiffre en tant qu’avant-dernier caractère et le dernier caractère n’est ni une lettre majuscule, ni un point d’interrogation.
Par exemple, les chaînes abcd3y ou 14d2f5* correspondent.

8 [357]y* => La chaîne correspondante (de longueur quelconque) comporte le chiffre 8, suivi d’un espace, puis d’un chiffre parmi 3, 5 et 7, puis de la lettre y répétée 0 à n fois.
Par exemple, les chaînes 8 5yyyyyyy, truc8 7 ou zse48 5ytruc correspondent.

Voilà, nous en avons fini avec tous ces caractères un peu étranges que vous serez amené à rencontrer et à utiliser dans le shell. Nous allons donc rentrer dans le vif du sujet dans le prochain article, avec une présentation de toutes les commandes de base à connaître, qui concernent principalement la manipulation des fichiers.

À RETENIR, ASTUCES ET À SAVOIR !

01 ► Lorsque vous vous connectez avec votre nom d’utilisateur, vos droits sur le système sont limités et certaines opérations vous sont refusées.Pour outrepasser ces limitations, vous pouvez prendre momentanément, via le terminal, l’identité du super-utilisateur ou administrateur système appelé root.
Pour cela, on distingue deux façon de procéder : soit vous précédez la commande souhaitée par sudo et vous devrez saisir votre mot de passe utilisateur, soit vous saisissez  la commande su et vous devrez saisir le mot de passe root. Dans ce dernier cas, vous serez root jusqu’à la fermeture de la session Bash.

 02 ► Pour rappeler la dernière commande contenant un terme en particulier, pas forcément en début de ligne, on utilise la syntaxe !?<motif>.
Par exemple, pour rappeler la dernière commande contenant le terme « install » :
~$ !?install
sudo aptitude install vlc

03 ► Le fichier de configuration de Bash /home/user/.bashrc, propre à chaque utilisateur du système permet de personnaliser le comportement et certaines fonctionnalités du shell de façon permanente. Après chaque modification dans ce fichier, il est nécessaire de fermer puis de rouvrir le terminal pour que les changements soient pris en compte.

04 ► La différence entre les deux types de commandes se joue au niveau de la performance : une sera toujours plus rapide, car elle découle directement du processus shell. En revanche, une commande externe est exécutée via un processus fils du processus courant, qui doit dupliquer l’environnement du processus père au préalable.

05 ► La variable d’environnement PATH contient une liste de répertoires contenant des fichiers exécutables. Les commandes dont le chemin d’accès est spécifié dans la variable PATH peuvent être lancées depuis n’importe quel endroit de l’arborescence de fichiers, sans mentionner leur chemin complet.

06 ► Les termes « foobar » , « foo » ou « bar » sont des termes passe-partout fréquemment utilisés dans les documentations relatives à l’informatique, en particulier en programmation. On les emploie à des fins de démonstration. On les emploie à des fins de démonstration , simplement pour représenter une variable (comme dans notre exemple), une fonction ou une commande quelconque.

07 ► Pour faire simple, on dit qu’un processus est l’instance d’un programme en cours d’exécution. Un processus est caractérisé par son PID, un identifiant unique assigné par le noyau du système.

08 ► Les numéros de job font référence aux processus exécutés en arrière-plan dans le shell ; les identifiants de processus font référence à tous les processus en cours d’exécution sur l’ensemble du système, pour tous les utilisateurs.

09 ► Outre le canal de l’entrée standard et le canal de sortie standard, il existe également un troisième canal : le canal d’erreurs. Par défaut, il est automatiquement redirigé vers la sortie standard, pour que vous puissiez visualiser la source de l’erreur en question.

10 ► Pour information, la commande wc utilisée ici permet de compter (et d’afficher dans cet ordre) le nombre de lignes, de mots et de caractères contenus dans le fichier.

11 ► On parle de « traitement par lots » lorsque l’on effectue en une fois la (ou les) même(s) opérations(s) sur tout un ensemble de fichiers, qui sont le plus souvent de même nature. Il peut s’agir de renommage, de conversion de format, de redimensionnement,ect.

À bientôt ….

linux-pratique