unix linux utilisation des systèmes - anakal.free.franakal.free.fr/ebooks d'informatique -...

Unix Linux:

utilisation des systèmes

Table des matières

Introduction..........................................................................................................................3avantpropos......................................................................................................................3versions d'Unix – Linux......................................................................................................4composantes......................................................................................................................6syntaxe des commandes.................................................................................................10connexion ........................................................................................................................11à l'aide !............................................................................................................................20TP : premières commandes.............................................................................................22

Arborescence unix – Linux...............................................................................................24Arborescence des systèmes Unix...................................................................................26Les types de fichiers........................................................................................................27Un inode, c'est quoi ?......................................................................................................28manipuler les fichiers.......................................................................................................29Les caractères spéciaux..................................................................................................43TP : Manipuler les fichiers...............................................................................................46afficher du texte...............................................................................................................48TP : Afficher le contenu des fichiers................................................................................56gestion des liens..............................................................................................................57TP : les liens....................................................................................................................60

Commandes de recherches..............................................................................................61Les expressions régulières..............................................................................................61Rechercher dans les fichiers...........................................................................................64 Rechercher dans l'arborescence ...................................................................................65TP : recherches................................................................................................................67

Editer du texte....................................................................................................................68vi.......................................................................................................................................69D'autres commandes ......................................................................................................78TP : vi...............................................................................................................................79

Processus et mécanismes................................................................................................82Les processus .................................................................................................................82les processus en arrière plan ..........................................................................................86priorité des processus .....................................................................................................89redirections.......................................................................................................................91pipelines...........................................................................................................................93TP : Redirections d'entrées/sorties..................................................................................95

Version : 0.6 1

Les droits d'accès..............................................................................................................96Gestion des Permissions.................................................................................................96TP : permissions............................................................................................................103

Archivage et compressions............................................................................................104archiver ..........................................................................................................................105compresser ...................................................................................................................108TP : sauvegardes...........................................................................................................112

Le shell..............................................................................................................................113les variables....................................................................................................................116les alias...........................................................................................................................119le rappel de commandes et la gestion de l'historique....................................................122

Les scripts........................................................................................................................128Créer des scripts............................................................................................................128Les variables dans les scripts........................................................................................130Les caractères spéciaux du shell...................................................................................132Les commandes internes au shell.................................................................................134les conditions (test, if, case)...........................................................................................136TP : scripting utiliser les éléments base......................................................................139les boucles (while, until, for)...........................................................................................142TP : scripting les structures de contrôle......................................................................146les fonctions...................................................................................................................150TP : scripting les fonctions...........................................................................................152

Des commandes pour les scripts ..................................................................................154TP : scripting les commandes......................................................................................171

Plus loin avec les variables.............................................................................................172Substitution de variables................................................................................................172L'arithmétique entière.....................................................................................................174les variables de tableau.................................................................................................176TP : scripting scripts de synthèse................................................................................177

Index des commandes.....................................................................................................178

mémo de vi........................................................................................................................180

mémo sur les tests...........................................................................................................184

Version : 0.6 2

Introduction

avantpropos

Unix est le premier système d'exploitation à ne pas avoir été écrit par un constructeur. Il a de ce fait ouvert une brèche dans un domaine jusque là réservé.

Qu'est-ce qu'un système d'exploitation ?

Un système d'exploitation est un programme ou un ensemble de programmes qui est chargé de gérer les ressources matérielles (périphériques, mémoires…) d'un ordinateur et de les mettre à disposition des utilisateurs.

Quelques exemples :

Systèmes propriétaires

GCOS (Bull)

MPE (HP)

OS400 (IBM)

Système ouvert mono poste, mono tâche (micro)

DOS

Système ouvert multiposte, multitâche, multiplateforme

UNIX

IntroductionVersion : 0.6 3

versions d'Unix – Linux

Historique

1969 BELL Lab se retire du projet MULTICS. Cependant, l'équipe de Bell Lab continue ses recherches. Dans cette équipe, on trouve trois grands noms de l'histoire d'UNIX : Ken Thompson, Dennis Ritchie et Brian Kernighan.

1971 Première version d'Unix sur PDP 11/20 (Digital Equipment Corporation). Matériel qui dispose de 24 Ko de mémoire dont 16 Ko occupés par le noyau Unix, 8 Ko restant disponibles pour les utilisateurs. Capacité du disque dur : 512 Ko, taille maximale des fichiers 64 Ko.Le langage C est créé par Dennis Ritchie (reprise du langage B qui avait été écrit par Ken Thompson)

1973 Le noyau UNIX est réécrit en langage C par Ken Thompson. Les autres outils utilisés sous UNIX le seront également.Cette version d' Unix est connue sous le nom "Unix Timesharing System V4"L'université de Californie à Berkeley est la première à disposer d' Unix (avec sources)

1976 Sortie d'Unix Timesharing System V6 aux Bell Labs d'AT&T. Version qui sera disponible avec les sources pour une somme symbolique. Les universités sont les premières concernées. Bell Lab d'AT&T développent UUCP (Unix to Unix Copy Program). Premier protocole d'échange de données qui sera très utilisé avant l'arrivée de TCP/IP.1982 SunOs 1.0 (dont l'origine est 4.1BSD)

1983 Création du projet GNU

1986 AIX/RT 2

1989 SCO Unix System V /386

1990 SunOs 4.1.1 (Solaris 1)

1991 Naissance du noyau Linux (version 0.02) et distribution sur les premiers serveurs ftp

1992 Solaris 2.0 (Sparc)

1996 Sortie de l'environnement de bureau KDE

1997 sortie de l'environnement de bureau Gnome

1997 SCO Open Server 5.0.4

AIX 4.3

2003 Solaris 9 X86 PE


composantes

Le noyau UNIX

Le noyau UNIX est le programme principal du système. Il est généré à l'installation et relié en cas de modification de configuration matérielle.

Son rôle est de :

Gérer les ressources d'un ordinateur à travers la couche logicielle (périphériques, mémoire, ...)

Ordonnancer les différentes tâches (processus)

Mettre ces ressources à la disposition des utilisateurs


Matériel

Noyau

Shell

Outils

Applications

Dans un sens plus large, on entend souvent par noyau Unix le noyau luimême ainsi que l'ensemble des programmes essentiels tels que :

les interpréteurs de commandes (shell)

l'assembleur

les compilateurs

l'éditeur de lien

les éditeurs de texte (vi, ed, sed)

les services divers (communication, impression…)

Les langages SHELL

Une commande est une suite de mots séparés par des espaces. Le premier mot est le nom de la commande, les éventuels mots suivants sont les arguments. Sous Unix, cet ensemble de mots est analysé et interprété par un programme appelé shell (interpréteur de commandes).

Attention ! Le shell différencie les majuscules et les minuscules.

Un shell peut être assimilé à un langage. Assez complet, il permet la déclaration de structures de contrôles (alternatives et répétitives) et la manipulation de variables. Il est possible d'enregistrer des ensembles de commandes dans des fichiers de commandes appelés scripts shell. Les commandes ainsi créées disposent des mêmes caractéristiques que les commandes système.

Un shell traite les informations entrées ou à restituer sous forme de flux. Par défaut, le shell lit une commande à partir du flux nommé stdin (correspondant au clavier), écrit le résultat sur le flux stdout (l'écran) et écrit les éventuelles erreurs sur le flux stderr (également l'écran). Ces trois flux peuvent être remplacés par un fichier ordinaire ou un fichier spécial (périphérique) grâce au mécanisme de redirections d'entrée/sortie.

SHELL : Interpréteur de commandes (pas de notion de compilation). Interface entre utilisateurs et système.

Les 4 principaux shell :

• le sh (Bourne Shell) est d'origine AT&T

• le csh (C Shell) provient des unix BSD

• le ksh (Korn Shell) est issu d'AT&T

• le bash (Bourne Again Shell) est le shell du projet GNU


Le ksh est un surensemble du sh, il combine les avantages du csh avec la syntaxe du bourne shell.

Le csh a une syntaxe proche du langage C, mais les procédures csh ne s'exécutent pas sous sh et ksh.

Les principales autres différences :

• historique dans csh et ksh

• éditeur de ligne dans ksh

• les syntaxes des boucles diffèrent entre csh, ksh et sh :

csh : while … end

ksh et sh : while … do … done

• goto n'existe qu'en csh

• le mécanisme de substitution des variables ksh est plus élaboré

• l'arithmétique entière n'existe qu'en csh et ksh

• le mécanisme d'alias (abréviation de commande) n'existe qu'en csh et ksh

Particularité sur les systèmes d'exploitation AIX, le Bourneshell s'appelle bsh

COMMANDES, OUTILS, LANGAGES

* Langages et compilateurs intégrés :• C cc ccompiler• Cobol• Fortran 77• Pascal, Basic• Java javac

* Editeurs de texte :• vi• ed• sed

* Utilitaires de développement :• JDK 1.4.2.05 (Java Development Kit)


• make Compilation conditionnelle en prenant en compte les dépendances• sdb Symbolic Debugger . .Point d'arrêt

. Source et compilé en parallèle

. variables

* Outils de traitement de texte et génération de document

* Outils de réalisation de compilateurs : yacc, lex

* Communication entre utilisateurs :• mail• write• uucp Unix to Unix Communication Protocol• tcp/ip avec FTP File Transfer Protocol

* Outils graphiques

* Outils d'administration• scoadmin sur version SCO Unix• smit sur version AIX• smc sur version SOLARIS

Modularité

La modification de la configuration n'implique pas la réinstallation du système.

Multipostes

Plusieurs utilisateurs peuvent accéder simultanément à un système Unix.

Multitâches

Un utilisateur peut lancer plusieurs traitements qui s'exécutent en parallèle

Notion de user et de group

Pour accéder à un système Unix, un utilisateur devra disposer d'un nom de user. Un user est toujours membre d'au moins un groupe (group). L'utilisateur root est l'administrateur du système.

Les fichiers

Les fichiers Unix se répartissent en trois grand types :• les fichiers ordinaires, qui sont de simples suites d'octets non structurées• les fichiers répertoires, contenant les références d'autres fichiers• les fichiers spéciaux (périphériques d'entrée/sortie, mémoire, tubes nommés)


syntaxe des commandes

L'utilisation de la ligne de commande impose le respect de certaines règles, sans lesquels il n'est pas possible d'utiliser correctement le système.

La manière habituelle de lancer une commande est de taper la commande suivie des options, puis des arguments

• La commande doit toujours être située en premier dans l'instruction.• Les options permettent de modifier le comportement par défaut de la commande.

Elles sont généralement précédés du signe moins – ou plus +. elles peuvent être séparées par des espaces ou regroupées ensemble.

• les arguments sont les éléments utiles à la commande, sinon indispensables. Certaines commandes n'ont pas besoin d'arguments, alors que pour d'autre les arguments seront obligatoires.

• La commande, les options et les arguments doivent etre séparés par un espace

commande options arguments

ex :

who commande simple sans options ni arguments

ls /etc commande avec un argument

head n 5 /etc/nsswitch.conf commande avec une option et un argument

cp /tmp/fic1 $HOME commande avec deux arguments

tar xzvf archive.tar.gz commande avec quatre options (sans signe + ou ) et un argument

ATTENTION : les systèmes unix respectent la casse, il faudra prendre garde à respecter les minuscules et les majuscules.


connexion

Connexion

Pour se connecter à un système Unix, un utilisateur doit disposer d'un nom de user, auquel est généralement associé un mot de passe.

Quand un terminal permet la connexion d'un utilisateur, il propose une invite de type :

A cette invite, il faut entrer le nom de user pour provoquer l'affichage de l'invite de saisie du mot de passe :

Sur Solaris :

Sur AIX :

Le système vérifie l'existence du user et la cohérence du mot de passe avant d'afficher, sur certaines versions d'Unix la valeur de la variable TERM, le message de bienvenue (stocké dans le fichier /etc/motd) et l'invite du shell de connexion :


Si la connexion ne peut être établie (mot de passe incorrect), et après un certain nombre d'essais, le compte utilisateur sera verrouillé. Celuici devra alors demander à l'administrateur d'intervenir.

Déconnexion

La commande de déconnexion (fermeture de session) dépend de l'environnement shell de l'utilisateur.

Bourne shell $ CTRL + D

Korn shell n$ exit

C shell n% logout


tty affiche le nom du terminal

Syntaxe : tty

Sur AIX

Sur SOLARIS l teste si la ligne du terminal est une ligne synchrone


logname Affiche le nom du user de connexion

Syntaxe : logname

Commande simple. Pas de paramètre.

id affiche les noms et identificateurs des groupes et du user

Syntaxe : id

Sur Solaris

Sur AIX


who am i qui suisje ?

Syntaxe : who am i

Sur Solaris

Sur AIX


who informations sur les users connectés

Syntaxe : who [ H q T u ]

H Heading, affichage entête de colonnes

q Liste abrégée, noms et nombre d'utilisateurs

T Indique par + ou – s'il est possible d'écrire sur le terminal

u Informations complémentaires sur les différentes connexions

Sans option, la commande who affiche le nom user, le terminal et la date et heure de connexion.

Sur Solaris


passwd changement du mot de passe

Syntaxe : passwd [ s ]

Sans option, la commande passwd permet de modifier le mot de passe.

Sur Solaris, non autorisé par défaut, nécessite un droit d'utilisation positionné par l'administrateur

Sur AIX s permet de changer le shell de connexion


date Affichage de la date et heure

Syntaxe : date [OPTION]... [+FORMAT]

date [ u | utc | universal ] [ MMDDhhmm [ [CC] YY ] [.ss] ]

mmdd numéro du mois et du jour

HHMM heure minutes

cc yy numéro du siècle et de l'année

+format format de visualisation de la date, composé de texte et de différents paramètres identifiés par le caractère %

%a nom du jour abrégé%A nom du jour%b nom du mois abrégé%B nom du mois%d numéro du jour (01 à 31)%D date sous forme mm/dd/yy%j numéro du jour dans l'année%m numéro du mois%U numéro de la semaine%w numéro du jour dans la semaine (0 = dimanche)%y année sur 2 chiffres%Y année sur 4 chiffres (siècle inclus)

%H heure de 00 à 23%I heure de 01 à 12%M minutes de 00 à 59%S secondes de 00 à 59%T heure (24) sous forme HH:MM:SS

%n insertion nouvelle ligne%t insertion tabulation

Si aucun argument n'est passé à la commande date, un simple affichage est effectué.

date "+%nBonjour, nous sommes le %A %B %Y.%nIl est %Hh%M%n"

ATTENTION : la commande date utilisée par root permet de modifier la date et l'heure du serveur.


cal Génération de calendrier

Syntaxe : cal [ [ mois ] année ]

mois numéro du mois

année numéro de l'année siècle inclus

Sur Solaris et AIX :

Sans argument, la commande génère le calendrier du mois courant.


à l'aide !

Les commandes unix peuvent comporter un grand nombre d'options, qui ne sont de plus pas toujours facile à comprendre. Il est donc très important sur les sytèmes Unix d'accéder à de la documentation aisément.

Localement

la commande man est le premier outil utilisé pour obtenir de l'aide. Les administrateurs les plus chevronnés utilisent tous les jours la commande man qui est une véritable mine d'or de l'aide en ligne.

Les outils en ligne de commandes possèdent généralement des options permettant d'afficher une aide rapide. Générelement, l'option help permet l'accès à un récapitulatif des options possibles.

passwd --help

Les outils graphiques quand à eux possèdent en général leur documentation, en passant par le menu aide ou en appuyant sur la touche F1.

Sur Internet

Les distributions Linux bénéficient de l'activité des nombreuses communautés d'utilisateurs, et la consultation des sites des éditeurs est souvent très riche d'enseignements. Les forums permettent de résoudre nombre de questions techniques et les tutoriels permetttent d'en savoir plus sur un sujet donné.

www.tldp.org The Linux Documentation Project

traduc.org Un site de traduction en français des nombreuses documentations sur Linux

docs.sun.com Documentation officielle pour Solaris (SUN)

docs.hp.com Documentation officielle pour HPUX (HP)

publibn.boulder.ibm.com/cgibin/ds_rslt#1 Documentation officielle pour AIX (IBM)


man

La commande man permet d'accéder rapidement à l'aide en ligne. Il est cependant bien souvent nécéssaire de maîtriser la langue de shakespeare car les pages de man sont rarement ou imparfaitement traduites. Les distributions Linux sont en général mieux loties en terme de traduction grâce à ses nombreuses communautés qui fournissent quotidiennement un effort de traduction. Il faudra cependant toujours prendre garde aux traductions imparfaites qui peuvent altérer le texte original.

Les pages de man sont scindées en différentes sections. Si aucune section n'est invoquée, man recherchera dans les sections selon un ordre prédéterminé, et s'arretera dès qu'une occurence sera trouvée. Si une section est passée en option, la recherche se fera uniquement dans la section trouvée

Exemple de sections (sur un système Linux Ubuntu 9.04) 1 : Programmes exécutables ou commandes de l’interpréteur de commandes (shell) 2 : Appels système (Fonctions fournies par le noyau) 3 : Appels de bibliothèque (fonctions fournies par les bibliothèques des programmes) 4 : Fichiers spéciaux (situés généralement dans /dev) 5 : Formats des fichiers et conventions. Par exemple /etc/passwd 6 : Jeux 7 : Divers (y compris les macropaquets et les conventions). Par ex man(7), groff(7) 8 : Commandes de gestion du système (généralement réservées à root) 9 : Sousprogrammes du noyau [hors standard].

Obtenir de l'aide sur la commande passwd :

$ man passwd

Obtenir de l'aide sur le fichier /etc/passwd (ici sous Linux) :

$ man -s 5 passwd

Obtenir de l'aide sur les pages de man

$ man man

Si l'on ne connait pas la commande dont on souhaite l'aide, il est possible de taper un mot clé. par exemple, pour connaître les commandes relatives au motclé password :

$ man -k password


TP : premières commandes

1. Changer votre mot de passe, fermer la session et reconnectezvous pour vérifier le changement de mot de passe :

..................................................................................................................................................

2. Depuis quand êtes vous connecté : ..................................................................................................................................................

3. Quels sont les utilisateurs qui travaillent sur le serveur : ..................................................................................................................................................

4. Quel est le temps d'inactivité des utilisateurs connectés :..................................................................................................................................................

5. Quel est le numéro de processus de votre session :..................................................................................................................................................

6. Afficher vos identifiants d'utilisateur et de groupes (UID et GID) :..................................................................................................................................................

7. Quels sont vos groupes d'appartenance :..................................................................................................................................................

8. A l'invite de commande, afficher juste l'heure :..................................................................................................................................................

9. A l'invite afficher juste la date suivant l'exemple lundi 24 septembre 2009:..................................................................................................................................................


10. Commande cal avec et sans argument :

a) Afficher le calendrier de Janvier 1900 puis celui de toute l'année :.....................................................................................................................................

.....................................................................................................................................

b) Afficher le calendrier du mois de Janvier de l'année courante :.....................................................................................................................................

c) Afficher le calendrier de septembre 1752, avezvous une idée sur la particularité de ce mois ?

.....................................................................................................................................


Arborescence unix – Linux

La structure du système de fichiers (FS) est arborescente (Imbrication de répertoire), le chemin d'accès à un fichier permet de spécifier la position exacte de ce fichier dans l'arborescence.

Chemin absolu vs chemin relatif

Lorsque le chemin commence par le caractère /, il est donné depuis la racine : on parle alors de chemin absolu, sinon, le chemin est donné à partir du répertoire courant : on parle dans ce cas de chemin relatif.

Si le chemin d'accès (absolu ou relatif) à un fichier est composé d'un ou plusieurs répertoires, le caractère / sépare les différents niveaux.

Répertoire père et répertoire courant

Chaque répertoire, en dehors de la racine, contient au minimum deux sousrépertoires particuliers :

.. le répertoire père

. le répertoire courant

Il peut être judicieux, dans certains cas, de remonter dans l'arborescence plutôt que de descendre. Dans ce cas, le nom de chemin contiendra ".." pour se positionner dans le répertoire de niveau immédiatement supérieur à celui dans lequel on est positionné.

Arborescence unix – LinuxVersion : 0.6 24

Dans l'arborescence cidessus, le répertoire exo contient un fichier b1, et le répertoire prog un fichier ediuser.

Si la position courante dans l'arborescence est le répertoire marie, le chemin d'accès au fichier b1 pourra être l'un des suivants :

/home/marie/exo/b1exo/b1

De même, le chemin d'accès au fichier ediuser pourra être :/home/marie/source/prog/ediusersource/prog/ediuser


/

home

marie

exo source

prog util divers

Arborescence des systèmes Unix

bin : Commandes de base UNIX

dev : fichiers de périphériques

devices : Noms physiques des périphériques (Solaris)

etc : Fichiers de configuration du système

export : Utilisé pour le partage de systèmes de fichiers

home : Répertoire d'accueil des utilisateurs.

kernel : Modules du noyau nécessaires au processus de démarrage (Solaris)

lost+found : Fichiers récupérés par la cde fsck

mnt : Répertoire d'accueil des arborescences diverses

opt : Répertoire pour les applications tierces.

platform : Modules du noyau propres à la plateforme (Solaris)

sbin : Exécutables essentiels au processus de démarrage

tmp : Fichiers temporaires

usr : Programmes, bibliothèques, scripts pour les users

var : Fichiers de taille variable (temporaires, journaux, état)


/

Les types de fichiers

Sous Unix, tout est Fichier

L'utilisateur perçoit les fichiers comme rangés dans des répertoires, euxmême classés dans d'autres répertoires, cela nous permet d'avoir une vision hiérarchique de l'organisation des fichiers et d'en faciliter la gestion.

Le système d'exploitation en a lui une toute autre vision. Pour lui, un fichier est un ensemble de données écrites sur le support de stockage, sans aucune notion hiérarchique, mais accessible par un inode qui possède des pointeurs vers ses données.

Pour Unix, un écran, la souris ou un disque dur sont représentés par des fichiers. Même les processus sont des fichiers.

Il existe quatre type de fichiers :

Fichiers ordinaires

Les fichiers ordinaires sont tous les fichiers dans le sens usuel du terme, ainsi, les textes, les scripts, les commandes sont des fichiers ordinaires

Répertoires

Le répertoires est pour le système un type de fichier particulier, contenant les références permettant d'accéder à des fichiers.

Fichiers spéciaux

Les fichiers spéciaux désignent les périphériques matériel de la machine, ils sont subdivisés en deux parties :

• les fichiers spéciaux en mode bloc, qui concernent les périphériques de stockage

• les fichiers spéciaux en mode charactère ou raw, qui eux représentent les périphériques d'entrées/sorties comme le clavier, la souris ou l'écran.

Liens symboliques

Un lien symbolique est un fichier spécial qui permet de pointer vers un nom de fichier. Ils permettent de simplifier les accès aux fichiers et répertoire et à maintenir la compatibilité entre systèmes Unix


Un inode, c'est quoi ?

Les inodes contiennent des informations concernant les fichiers stockés sur les systèmes de fichiers. Les inodes sont référencés par des numéro.

Lorsqu'un utilisateur tente d'accéder à un fichier, l'inode du fichier est lu. Si les permissions autorisent l'accès au fichier, les données seront accessibles grâce aux pointeurs.

L'inode contient des informations telles que :• l'identifiant de l'utilisateur propriétaire du fichier;

• l'identifiant du groupe propriétaire du fichier;

• les permissions d'accès au fichier;

• les dates de dernière modification, de dernier accès et de dernière modification de l'inode;

• la taille du fichier;

• le nombre de lien du fichier (nous y reviendrons);

• le type de fichier;

• les pointeurs qui permettent d'accéder physiquement aux données du fichier.

ATTENTION : L'inode ne contient pas le nom du fichier


.

..fichier.txt (12345)

rep1

propriétairegroupe

permissionsnombre de liens

datestaille

pointeurs

12345

manipuler les fichiers

La gestion des fichiers implique de respecter des règles dans la désignation des fichiers :

Pas de notion d'extension

Les noyaux des systèmes Unix ne gère pas la notion d'extensions de fichier comme Windows. Aussi, le fait d'appeler un fichier fic.txt ou programme.exe n'indique en rien au système que nous avons à faire à un fichier texte ou un à une application. L'utilisation des extensions sera donc uniquement utile à l'utilisateur, pour reconnaître les types de fichiers.

Caractères interdits

hormis le slash / qui est le séparateur dans l'arborescence, il n'y a pas de caractères interdits pour le nommage des fichiers. Il faudra malgré tout prendre garde aux caractères spéciaux qui peuvent être difficiles à manipuler.

Gestion de la casse

Attention à la casse, fichier.txt, Fichier.txt et FICHIER.TXT sont trois fichiers différents.

les fichiers cachés

Les fichiers qui commencent par un point "." sont considérés comme "cachés" par certaines commandes et par les gestionnnaires de fichiers graphiques. Les fichiers de configuration des environnements utilisateurs contiennent souvent de tels fichiers.

Longueur des noms de fichiers

Les noms de fichiers peuvent atteindre 255 caractères.


pwd affiche le chemin du répertoire courant

Syntaxe : pwd

La commande pwd affiche le répertoire courant, c'est à dire le répertoire dans lequel l'utilisateur se trouve au moment de l'exécution de la commande.

C'est une des rares commandes sans options ni arguments.

$ pwd

/home/beni


cd changement de répertoire

Syntaxe : cd [ chemin ]

chemin Le chemin du répertoire dans lequel on veut se positionner.

Ce chemin peut être donné en absolu ou en relatif.

Sans indication du chemin, la commande cd permet de se positionner automatiquement dans le répertoire de connexion.


mkdir création de répertoire

Syntaxe : mkdir [ m mode ] [ p ] nomrep

m mode mode est une valeur numérique permettant de fixer les permissions du répertoire si nécessaire

p création des répertoires parents inexistants (si nomrep est un chemin)

nomrep nom du répertoire ou du chemin à créer


rmdir suppression de répertoire

Syntaxe : rmdir [ p ] nomrep

p suppression des répertoires parents uniquement s'ils sont vides

nomrep nom du répertoire ou du chemin à supprimer


ls liste de fichiers

Syntaxe : ls [ aACdFilmrRstux ] [ répertoire | fichier(s) … ]

a liste de tous les fichiers, y compris les fichiers dont le nom commence par "." répertoires père et courant inclus

A liste de tous les fichiers, y compris les fichiers dont le nom commence par "." sauf les répertoires père et courant

C présentation en colonnes avec tri vertical

d affiche le nom des répertoires de façon identique au nom de fichier

F présentation en colonnes avec tri vertical, certains noms sont suivis d'un caractère indiquant le type : / pour un répertoire, * pour un fichier exécutable et @ pour un lien symbolique

i affiche le numéro d'inode

l affichage au format long : type et permissions, nombre de liens physiques, owner, group, taille (en octets) pour un fichier, date de dernière modification et nom du fichier ou répertoire

m présentation sous forme de liste de noms séparés les uns des autres par ","

r affichage des noms avec tri inversé

R liste récursive de tous les sous répertoires

s affiche la taille en blocs des fichiers (1 bloc = 512 octets)

t tri par date de dernière modification

u tri par date de dernier accès

x présentation en colonnes avec tri horizontal

rép nom du répertoire dont on souhaite visualiser le contenu

fichier nom du ou des fichiers concernés par la liste

La commande ls permet de lister les noms (et caractéristiques) d'un fichier ou d'un ensemble de fichiers. Par défaut, les noms de fichiers sont affichés par ordre alphabétique.

Les arguments répertoire et fichier peuvent contenir des métacaractères. Si aucun argument n'est spécifié à la commande ls, cette commande liste le contenu du répertoire courant.


Sur Solaris et AIX, ls et ls –C donnent le même résultat d'affichage, pour obtenir un affichage sur une seule colonne, il faut associer l'option 1 (un) à la commande ls


# ls -l /etc

...

-rw-r--r-- 1 root root 1467 2010-02-25 23:55 passwd

-rw------- 1 root root 1521 2010-02-25 16:15 passwd-

drwxr-xr-x 4 root root 4096 2009-10-30 13:56 perl

drwxr-xr-x 5 root root 4096 2009-10-30 16:20 pm

-rw-r--r-- 1 root root 7649 2009-10-30 16:24 pnm2ppa.conf

drwxr-xr-x 4 root root 4096 2009-10-30 16:17 polkit-1

-rw-r--r-- 1 root root 350 2009-10-30 14:13 popularity-contest.conf

drwxr-xr-x 8 root dip 4096 2009-10-30 14:13 ppp

lrwxrwxrwx 1 root root 22 2009-11-12 16:41 printcap -> /var/run/cups/printcap

-rw-r--r-- 1 root root 497 2009-10-30 13:56 profile

drwxr-xr-x 2 root root 4096 2009-10-20 02:04 profile.d

-rw-r--r-- 1 root root 2626 2009-09-15 14:02 protocols

drwxr-xr-x 2 root root 4096 2010-02-16 16:58 pulse

drwxr-xr-x 2 root root 4096 2010-03-01 12:52 purple

drwxr-xr-x 2 root root 4096 2009-10-30 13:57 python

drwxr-xr-x 2 root root 4096 2010-01-05 18:01 python2.6

1 Ensemble de 10 caractères indiquant le type du fichier (c1) et les permissions sur ce fichier pour le user (c234), le groupe (c567) et les autres (c8910).

type de fichier fichier ordinaired répertoireb périphérique de type blocc périphérique de type caractèrel lien symboliquep tube nommé (FIFO)

permissions pas de droit toutes positionsr droit de lecture première positionw droit d'écriture deuxième positionx droit d'exécution troisième position

2 Nombre de liens physiques pour un fichier, nombre de sousrépertoires (+ 2) pour un répertoire

3 Nom du user propriétaire4 Nom du groupe propriétaire


1 2 3 4 5 6 7

5 Taille en octets pour un fichier6 Heure et/ou date de dernière modification7 Nom du fichier ou du répertoire


touch modifier les dates de fichiers

Si les systèmes Windows ou Netware s'appuient sur un attribut "archive" pour réaliser des sauvegardes différentielles ou incrémentales, les systèmes Unix ne possèdent pas d'attribut permettant de savoir si un fichier doit être sauvegardé ou non.

Pour cela on utilise en général la date de dernière modification du fichier. Lors d'une sauvegarde complète ou incrémentale, il suffit d'utiliser un fichier de référence horodaté à une date voulue, et d'effectuer la sauvegarde des fichiers en fonction de la date de référence.

Accessoirement la commande touch crée un fichier lorsque le fichier mentionné n'existe pas, ce qui est très pratique pour réaliser des exercices sur des fichiers.

Nous ne rentrerons pas dans le détail de la commande touch, car la principale utilisation que nous en auront étant la création de fichiers vides.

Modifier la date de modification du fichier, s'il n'existe pas créer le fichier (il sera vide).

$ touch test.fic

Noter que la date de dernier accès, ainsi que la date de changement de l'inode sont également modifiés lors d'une modification du contenu du fichier.

Vérifier les changements

$ ls -l test.fic

Une autre commande, plus riche mais pas toujours présente :

$ stat test.fic


cp copie de fichiers

Syntaxe : cp nomfichO nomfichC

cp nomfichO1 [ nomfichOn ] nomrep

nomfichO fichier origine ou nom du fichier à copier

nomfichC fichier cible ou nom du fichier à générer

nomfichO1 … n fichier(s) à copier

nomrep répertoire dans lequel les fichiers précédemment nommés doivent être copiés

Les noms de fichiers et répertoires peuvent être des chemins absolus ou relatifs.


rm suppression de fichiers ou de répertoire

Syntaxe : rm [ fir ] nomfich [ …]

r Suppression récursive. Appliquée à un répertoire, supprime le répertoire et son contenu, y compris tous les répertoires de niveau inférieur.

i Demande de message de confirmation de suppression pour chaque fichier

f Supprime le message de confirmation automatique si le user (propriétaire) n'a pas le droit d'écriture sur le fichier

Fin des options ou aucune option, utilisé si l'on souhaite supprimer un fichier dont le nom est –f ou –r par exemple.

nomfich Nom du fichier ou du répertoire à supprimer. Ce nom peut être générique


mv déplacer ou renommer un fichier

Syntaxe : mv nomfichO nomfichD

mv nomrepO nomrepD

mv nomfichO1 [ nomfichOn ] nomrep

nomfichO fichier origine ou nom du fichier à déplacer ou à renommer

nomfichD nouveau nom de fichier

nomrepO nom du répertoire à déplacer ou à renommer

nomrepD nouveau nom du répertoire

nomfichO1 … n nom(s) de fichier(s) à déplacer

nomrep nom du répertoire dans lequel les fichiers doivent être placés

Les noms de fichiers et répertoires peuvent être des chemins absolus ou relatifs.


file détermine le type de fichier

Syntaxe : file nomfich

nomficnom du fichier. Ce nom peut être générique


Les caractères spéciaux

Les commandes de gestion de fichiers autorisent l'utilisation de métacaractères qui peuvent être combinés avec des caractères dits spéciaux.

Métacaractères

Les métacaractères sont des caractères de substitution utilisés pour définir des noms génériques. Ces caractères sont les suivants :

* 0 à n caractères

? 1 caractère quelconque et un seul

[ liste car.] 1 seul caractère parmi ceux de la liste entre [ ]

[car. Début car. Fin] 1 seul caractère compris dans l'intervalle de caractères, bornes incluses

[ ! … ] négation, 1 seul caractère autre que ceux spécifiés entre [ ]

Exemple :

*.c tous les noms qui se terminent par " .c "

ab?h tous les noms de quatre caractères qui commencent par "ab" et se terminent par "h", la valeur du troisième caractère est quelconque

ab[bhmp]15 tous les noms de cinq caractères qui commencent par "ab" et se terminent par "15", la valeur du troisième caractère est "b" ou "h" ou "m" ou "p"

ab[ah15]2 tous les noms de quatre caractères qui commencent par "ab" et se terminent par "2", la valeur du troisième caractère doit être comprise entre "a" et "h" ou entre "1" et "5"

ab[!aei]h tous les noms de quatre caractères qui commencent par "ab" et se terminent par "h" dont le troisième caractère n'est pas "a" ou "e" ou "i"

[ A Z ] 1 caractère parmi les lettres majuscules

[ A Z a z] 1 caractère parmi toutes les lettres minuscules et majuscules


Les expressions complexes

En plus des métacaractères, les environnements ksh et bash disposent d'expressions complexes permettant d'étendre les possibilités des remplacements de caractères :

?( … ) 0 à 1 fois l'expression entre parenthèses.

*( … ) 0 à n fois l'expression entre parenthèses.

+( … ) 1 à n fois l'expression entre parenthèses.

@( … ) 1 fois l'expression entre parenthèses.

!( … ) l'expression entre parenthèses ne sera pas présente

Nota : en bash, il faudra s'assurer que l'utilisation des expressions complexes est activée grâce à l'option extglob :

$ shopt

$ shopt -s extglob


Caractères spéciaux

En plus des métacaractères, le shell interprète de façon particulières certains caractères appelés caractères spéciaux.

Ces caractères sont les suivants :

' ' Simple quote banalisent tous les caractères situés entre les simple quote

echo 'prix : 15$50'

" " double quote banalise tous les caractères situés entre les doubles quotes sauf $ ` \ (dollar backquote et antislash)

echo "aujourd'hui, vous êtes connecté sur $HOSTNAME"

\ antislash banalise le caractère suivant

$ dollar permet d'afficher le contenu d'une variable

`….` back quote permet l'utilisation du résultat d'une commande

Un équivalent est : $(.....)


TP : Manipuler les fichiers

1. Où êtesvous positionnés dans l'arborescence :..................................................................................................................................................

2. Existetil des fichiers et des répertoires ?..................................................................................................................................................

3. Créer un fichier vide appelé MonPremierFichier :..................................................................................................................................................

4. Afficher les permissions et le propriétaire attribués à ce fichier : ..................................................................................................................................................

5. Afficher les fichier se terminant par l'extension .conf dans le répertoire /etc : ..................................................................................................................................................

6. Affichez les caractéristiques détaillées du répertoire /tmp (pas son contenu), que remarquez vous de particulier ?

..................................................................................................................................................

7. Affichez les fichiers et répertoires (pas leur contenu) dont le nom commence par a, b, c ou d du répertoire /etc :

..................................................................................................................................................


8. Créez l'arborescence suivante dans votre répertoire de travail ($HOME) :

$HOME

bin Tp

Bourne KornShell Divers

Sources lib Executables

..................................................................................................................................................

9. Positionnezvous dans le répertoire Sources. Dans ce répertoire, créez un fichier qui comporte, dans son nom, un astérisque :

..................................................................................................................................................

..................................................................................................................................................

10. Sans vous déplacez dans l’arborescence, essayez de supprimer le répertoire Sources . Que constatezvous ?

..................................................................................................................................................

11. Supprimer le répertoire Divers en utilisant la commande rm : ..................................................................................................................................................


afficher du texte

cat affichage et concaténation de fichiers

Syntaxe : cat [ options ] [ fichier … ]

n afficher les numéros de lignes (identique à la commande nl)

b affiche les numéros de lignes nonvides

s n'affiche pas les lignes vides consécutives

fichier nom (éventuellement générique) du ou des fichiers

Si plusieurs fichiers sont concernés par la commande cat, le contenu de chacun d'eux sera concaténé.

Si aucun fichier n'est spécifié, la commande cat va rechercher son flux d'entrée au clavier et ne s'exécutera qu'à la réception de fin de flux d'entrée : CTRL D


more Visualisation avec pause à chaque page écran

Syntaxe : more [ options ] [ nblig ] [ nomfichier ]

d Affiche un message d’aide en bas de page

[Hit space to continue, Del to abort]

s Ne conserve qu’une ligne blanche si plusieurs lignes blanches consécutives

nblig nblig définit le nombre de lignes de la page de visualisation

nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande more travaille sur le flux d’entrée

A ce stade de l’affichage, il est possible d’exécuter un certain nombre de commandes. Parmi ces commandes, il en est une à retenir : h ou ? qui permet d’obtenir l’aide en ligne des sous commandes de more.

La commande v permet quant à elle de faire appel à l’éditeur vi.


less Visualisation avec pause à chaque page écran

Similaire dans son principe à la commande more, less, commande très utilisée sur les environnements Linux, en améliore le fonctionnement.

Syntaxe :

less [options] fichier1 [fichier2]

La commande less offre l'avantage de ne pas quitter la lecture du fichier lorsque le curseur arrive à la fin du fichier. D'autre part, la recherche de chaînes de caractères est plus lisible.

Quelques commandes à effectuer lors de la lecture

h : accéder à l'aide

q : quitter le fichier ou l'aide

/Rigel : rechercher la chaîne Rigel

n pour continuer la recherche vers le bas

N pour continuer la recherche vers le haut

G : positionne en fin de fichier

g : positionne en début de fichier


head Affichage des premières lignes d’un fichier

Syntaxe : head [ nnbl ] [ nomfichier ]

nnbl Nombre de lignes à afficher (10 par défaut)

nomfichier Nom du fichier à traiter. Ce nom peut être générique.

A défaut de nom, la commande travaille sur le flux d’entrée

Sur AIX :

cnbc Nombre de caractères à afficher (tous par défaut)


tail Affichage des dernières lignes d’un fichier

Syntaxe : tail [nb ] [ nomfichier ]

Par défaut, tail affiche les 10 dernières lignes du fichier

nb Position, de début d'affichage, à partir de la fin du fichier

+nb Position, de début d'affichage, à partir du début du fichier

nomfichier Nom du fichier à traiter. Ce nom peut être générique.

A défaut de nom, la commande travaille sur le flux d’entrée

Affichage des 15 dernières lignes du fichier cal2002 :

Affichage des dernières lignes du fichier cal2002 à partir de la ligne 40 :


wc compte les lignes, mots et caractères de fichiers

Syntaxe : wc [ lwc ] nomfich [ …]

l affiche le nombre de lignes

w affiche le nombre de mots

c affiche le nombre de caractères

nomficnom du fichier. Ce nom peut être générique

Sans option, la commande wc affiche les trois informations.


cmp comparaison de fichiers

Syntaxe : cmp nomfich1 nomfich2

nomfich1 2 noms des fichiers à comparer.

La commande cmp indique la position (caractère, ligne) de la 1ère différence.


diff liste des différences entre deux fichiers

Syntaxe : diff nomfich1 nomfich2

nomfich1 2 noms des fichiers à comparer.

Actions : a pour append

c pour change

d pour delete

dans l'un ou l'autre des deux fichiers comparés.

< les lignes précédées de < concernent le premier fichier

> les lignes précédées de > concernent le second fichier


TP : Afficher le contenu des fichiers

1. Créer un nouveau fichier appelé MonDeuxiemeFichier à l'aide de la commande cat, dont le contenu sera :

Conseil :

pour bien utiliser la ligne de commande

faire des étirements de doigts avant chaque repas...................................................................................................................................................

2. Créer un fichier MonTroisiemeFichier avec cat, contenant le texte :

Ne pas oublier de lire au moins 4 pages de man

avant d'aller se coucher..................................................................................................................................................

3. Créer un nouveau fichier fichier2+3 par concaténation des deux fichiers qui viennent d'être créés :

..................................................................................................................................................

4. Combien de comptes d'utilisateurs ont été créés sur la machine, sachant que le fichier contenant les utilisateurs est /etc/passwd et qu'une ligne correspond à un utilisateur ?

..................................................................................................................................................

5. Afficher uniquement les 2 premières lignes du fichier /etc/hosts :..................................................................................................................................................


gestion des liens

ln Gestion des liens sur fichier et répertoire

Syntaxe : ln [ s ] nomfich nomlien

s Option de création d'un lien symbolique. Par défaut lien physique

nomfich Nom du fichier à partir duquel le lien doit être créé

nomlien Nom du lien

Lien physique

Un lien physique correspond à une autre référence, dans le même répertoire ou dans un autre, qui pointe sur l'inode d'un fichier existant.

Exemple : Il existe un fichier fsource (inode 2133) auquel on souhaite accéder sous le nom de flien

Schéma du résultat de la commande : ln fsource flien


marie

fsource flien

2133

référence

inodeinode

corps

Suppression d'un lien physique :

On peut supprimer n'importe quelle référence (n'importe quel fichier lié) sans que les autres soient modifiées.

Ce n'est que lorsque la dernière référence sera supprimée que le fichier (corps) sera supprimé aussi.

Contraintes des liens physiques :

Toutes les caractéristiques (sauf le nom ou référence) des fichiers liés sont toujours identiques (même propriétaire, mêmes permissions…).

Toute modification effectuée sur un fichier est systématiquement héritée par tous les fichiers liés physiquement.

Tous les fichiers liés doivent être situés dans le même filesystem.

Il est impossible de créer un lien physique sur un répertoire

Avantages des liens physiques :

Lors du déplacement (commande mv) d'un des fichiers liés (dans le même filesystem) tous les liens restent intacts.

Un lien physique ne provoque pas d'utilisation de nouvel inode.

Lien symbolique

Un lien symbolique consiste à créer un tout petit fichier (nouvel inode) d'un type spécial, dont le contenu correspond à la localisation (absolue ou relative) du fichier auquel il est lié. La taille de ce fichier est égale au nombre de caractères du chemin du fichier d'origine.


/home/marie

forigfliensym

2147

référence

inodeinode

corps

/tmp

151

lecture ou écriture

Exemple : Il existe un fichier /home/marie/forig (inode 2147) pour lequel on souhaite créer un lien symbolique dans /tmp sous le nom de fliensym.

ln –s /home/marie/forig /tmp/fliensym

L'inode du fichier fliensym est 151, sa taille 17 octets et le type "l".

Un accès au contenu d'un lien symbolique nécessite pour le système deux accès successifs, un premier pour lire le nom du fichier pointé par le lien, un second pour accéder au fichier pointé et lire les données de ce dernier.

Suppression d'un lien symbolique :

La suppression d'un lien symbolique par la commande rm provoque la destruction du fichier qui contient le nom du fichier pointé. Le fichier pointé n'est pas altéré.

La suppression du fichier pointé, en conservant un lien symbolique sur celuici, provoque la destruction du fichier pointé et la modification du lien symbolique qui, après cette opération existe toujours mais ne pointe plus sur RIEN.

Le fait de récréer un fichier pointé du même nom que le précédent revalide le lien symbolique.

Contraintes d'un lien symbolique

Un lien symbolique augmente le temps d'accès aux données : le système doit faire deux lectures pour accéder aux données.

Si le fichier sur lequel pointe le lien symbolique est déplacé ou supprimé, le lien continue d'exister mais ne pointe plus sur RIEN.

Avantages d'un lien symbolique

Le problème de filesystem (disque physique ou partition) n'existe pas. Un lien symbolique peut être fait n'importe où dans l'arborescence.

Il est possible de créer des liens symboliques sur des répertoires.

La commande ls –l permet de lire clairement le nom du fichier pointé par le lien.

Si le fichier origine est supprimé puis recréé ensuite sous le même nom au même endroit, le lien est toujours valide.


TP : les liens

1. Créez un lien physique du fichier Edition vers le fichier edition1.txt, vérifiez que vous pouvez afficher son contenu :

..................................................................................................................................................

..................................................................................................................................................

2. Créez un lien symbolique du fichier edition1.txt vers le fichier edition2.txt, vérifiez que vous pouvez afficher son contenu :

..................................................................................................................................................

..................................................................................................................................................

3. Créez un lien physique du fichier edition1.txt vers le fichier edition3.txt, vérifiez que vous pouvez afficher son contenu :

..................................................................................................................................................

..................................................................................................................................................

4. Affichez avec la commande ls les caractéristiques de ces 4 fichiers en mettant en évidence les différences :

..................................................................................................................................................

5. Supprimez le fichier edition1.txt, pouvez vous afficher le contenu de edition2.txt et edition3.txt ?

..................................................................................................................................................

..................................................................................................................................................


Commandes de recherches

Les expressions régulières

Introduction aux expressions régulières

Une expression régulière est un modèle de chaîne de caractères auquel peut être associé un certain nombre de chaînes de caractères avec des caractéristiques communes : celles de l'expression régulière.

Une expression régulière est construite à l'aide de différents caractères dont certains ont une signification particulière. Ce sont les caractères spéciaux.

Les expressions régulières sont utilisés par les outils d'édition et de recherche dans les fichiers tels que vi, grep, sed, awk, ed, ex, et autres.

Caractères spéciaux

Les caractères spéciaux ont une signification particulière qu'ils perdent s'ils sont précédés du caractère \

. 1 caractère quelconque et un seul

. correspond à : a ou b ou x ou 2 …

.. correspond à : aB ou AA …

* répétition du caractère qui précède de 0 à n fois

a* correspond à : <rien> ou a ou aa ou aaa …

Commandes de recherchesVersion : 0.6 61

.* une séquence de caractères quelconque, correspond à :

<rien> ou une suite d'un nombre quelconque de n'importe quel caractère

[liste car] 1 seul caractère parmi ceux de la liste entre [ ]

[abc12] correspond à : a ou b ou c ou 1 ou 2

[intervalle caractères] [car. Début car. Fin] 1 seul caractère dans l'intervalle [AZ]correspond à une lettre majuscule

[AZaz] correspond à toutes les lettres minuscules et majuscules

[ah15] correspond à un caractère a ou b ou c … ou h ou 1 ou 5

[hm][08] correspond à h0 ou h8 ou i0 ou i8 ... ou m0 ou m8

[^caractères] 1 seul caractère autre que ceux entre [ ]

[^abc] correspond à un caractère autre que a , b et c

^chaîne chaîne de caractères placée en début de ligne

^B une ligne qui commence par B

^[aA\t] une ligne qui commence par a ou A ou par une tabulation

^[ \t]* une ligne qui commence par espace ou tabulation répété de 0 à n fois

chaîne$ chaîne de caractères placée en fin de ligne

fin$ une ligne qui se termine par fin

[^xyz]$ une ligne qui se termine par n'importe quel caractère autre que x, y ou z

^$ une ligne vide

^.*$ la totalité de la ligne quelque soit son contenu


\<mot un mot qui commence par "mot" sans tenir compte des espace avant.

mot\> un mot qui finit par "mot" sans tenir compte des espaces avant.

Facteurs d'occurrences

car\{m,M\} un caractère répété au minimum m fois et au maximum M fois

ab\{1,3\}c correspond à : abc ou abbc ou abbbc

car\{n, \} un caractère répété au minimum n fois

es\{2,\}ai correspond à : essai mais aussi à esssai, essssai …

car\{n \} un caractère répété n fois exactement

[AZ]\{3\} correspond à une chaîne de caractères composée de 3 majuscules


Rechercher dans les fichiers

grep Recherche d'expression dans les fichiers

Syntaxe : grep [ options ] [ f fichexpr ] [ e ] expression [ nomfich ]

c Nombre de lignes contenant l'expression

h Suppression du nom de fichier lorsque la recherche est faite dans plusieurs fichiers

i Ignore la distinction minuscule et majuscule

l Affiche uniquement le nom des fichiers contenant l'expression

n Chaque ligne est précédée de son numéro dans le fichier

v Affiche uniquement les lignes qui ne contiennent pas l'expression

f fichexpr Fichier dans lequel se trouve l'expression à rechercher

e Option facultative qui précède l'expression à rechercher

expression Expression régulière directement spécifiée ou stockée dans un fichier. Il est préférable de la protéger par des simples quotes.

nomfich Nom du fichier dans lequel la recherche doit être faite. Ce nom peut être générique. S'il n'est pas spécifié, la recherche est faite sur le canal d'entrée.

Rechercher, sans tenir compte de la casse, les lignes qui commençant par dupont dans le fichier Edition :

# grep -i "^dupont" Edition


Rechercher dans l'arborescence

find Recherche sur les noms de fichier et répertoire

Syntaxe : find chemin expr [ action ]

chemin Nom du ou des répertoires à partir desquels la recherche va être faite

expr Critères de recherche qui permettent une sélection très précise des fichiers. Ces critères sont très nombreux, mais les suivants sont les plus courants :

name nom recherche en fonction du nom. Ce nom peut être générique et dans ce cas, il doit être protégé par des quotes.

user nom recherche des fichiers dont le user propriétaire est nom.

group nom recherche des fichiers dont le groupe propriétaire est nom.

type t recherche en fonction de la nature des fichiers. t peut prendre les valeurs suivantes :

f fichier ordinaire

d répertoire

l lien symbolique

b fichier spécial en mode bloc

c fichier spécial en mode caractère

p canal nommé

perm [ ] perms recherche en fonction des droits. perms peut être exprimé en notation octale ou symbolique. Si la valeur de perms est négative, seul les fichiers dont les droits sont au moins perms seront retenus, dans le cas d'une valeur positive, les fichiers retenus seront ceux pour lesquels les droits sont strictement égaux à perms

size nb [c] recherche en fonction de la taille des fichiers exprimée en blocs (de 512 octets) ou en octets si nb est suivi du caractère c. Pour une


comparaison en blocs, la taille des fichiers est arrondie au bloc supérieur. Une comparaison octets impose que le ou les fichiers recherchés aient exactement le même nombre d'octets que celui spécifié par l'option size.

newer nom recherche les fichiers dont la date de modification est plus récenteque la date de modification du fichier nom.

atime nb recherche des fichiers sur la date de dernier accès. nb correspond au nombre de jours (1 pour la veille, 2 pour 2 jours avant, 3 pour 3 jours avant…)

ctime nb recherche des fichiers sur la date de création ou de dernière modification

mtime nb recherche des fichiers sur la date de dernière modification

inum num recherche des fichiers sur le numéro d'inode

print Affichage des noms de fichiers trouvés au fur et à mesure

exec cmd [ options ] { } \; Pour chaque fichier trouvé, exécution de la commande cmd. Le nom de chaque fichier est symbolisé par {} . La commande se termine obligatoirement par un espace suivi des caractères \;

ok cmd [ options ] { } \; Identique à exec avec demande de confirmation pour chaque execution de cmd

! Opérateur de négation

o Opérateur OU

a Opérateur ET (And)

( ) Parenthèse de regroupement. Attention, ces parenthèses doivent être protégées par \

Rechercher dans le répertoire /etc les fichiers réguliers ayant l'inode 24621

$ find /etc -type f -inum 24621

Rechercher dans son répertoire d'accueil les fichiers suffixés en .tmp et les supprimer

$ find $HOME -type f -name ".tmp" -exec rm {} \;


TP : recherches

1. Rechercher toutes les lignes contenant Dupont dans le fichier Edition :..................................................................................................................................................

2. Rechercher toutes les lignes contenant dupont quelque soit la casse dans le fichier Edition :

..................................................................................................................................................

3. Afficher toutes les lignes non vides du fichier Edition :..................................................................................................................................................

4. Lister les fichiers contenant localhost dans le répertoire /etc sans inclure les sousrépertoires :

..................................................................................................................................................

5. Rechercher tous les fichiers standards commençant par ho à partir du répertoire /etc :..................................................................................................................................................

6. Rechercher tous les répertoires depuis votre répertoire personnel :..................................................................................................................................................

7. Rechercher tous les fichiers standards de votre répertoire personnel se terminant par txt et en faire une copie avec l'extension .save :

..................................................................................................................................................


Editer du texte

Tous les systèmes d'exploitation basés sur Unix implémentent vi, il est l'éditeur de texte standard, est conçu pour fonctionner sur tout type de terminal et se contente d'un clavier minimum (sans touches de flèches, pavé numérique, etc).

Le korn shell traditionnellement utilisé sur les Unix s'appuie sur vi pour exploiter l'historique des commandes.

Certains utilitaires l'utilisent également par défaut pour l'édition de fichiers texte, comme le plannificateur de tâches cron.

En bref, il n'est pas concevable d'envisager l'administration de machines basées sur des systèmes Unix sans aucune connaissance de l'éditeur vi.

Sous Linux, c'est l'éditeur vim qui est utilisé à la place de vi. Il y ajoute certaines fonctionnalités, telles que reconnaissance de certains langages de programmation qui permet la coloration syntaxique, l'annulation sur plusieurs commandes, et un plus grand nombre d'options de l'environnement de travail.

il existe d'autres éditeurs de fichiers intérréssants, nous en citerons quelques uns ici :

emacs Le principal concurrent de vi dans la guerre des éditeurs

nano issu d'un autre éditeur : pico

joe acronyme récursif de Joe's Own Editor

jed multiplatforme : unix, windows, beos, qnx, etc.

jedit écrit en java, particulièrement pratique pour les développeurs de pages web en css, xhtml, php

ne un éditeur simple à utiliser (la touche echap permet d'accéder à un menu comme sur un éditeur graphique)

Editer du texteVersion : 0.6 68

vi

VI est l'éditeur de texte standard d'Unix. Il fonctionne en mode plein écran, ce qui implique que le type de terminal utilisé a beaucoup d'importance. La variable d'environnement TERM permet d'indiquer ce type de terminal.

Les modes de travail

mode insertion, saisie de texte

mode commande, les caractères tapés sont interprétés comme des commandes

mode commande ex, commandes de bas de page précédées de ":" (deuxpoints).

Les commandes se répartissent en 5 grandes catégories :

les commandes de déplacement/positionnement (qui n'altèrent pas le texte)

les commandes de modification de texte

les commandes d'entrée/sortie

les commandes diverses

la définition de l'environnement de fonctionnement VI

Un appui sur la touche <Esc> permet de revenir en mode commande.

Lancement de vi

vi [ options ] [ nomfich … ]

options :

R Lecture uniquement

+nb Positionnement dans le fichier à la ligne nb

+/chaîne Positionnement dans le fichier sur la première occurrence de chaîne

A l'entrée dans VI, vous êtes automatiquement en mode commande.


Sortie de vi

ZZ sauvegarde et sortie de VI. La date de dernière modification sera affectée

:x uniquement si de réelles modifications ont été effectuées

:wq sauvegarde et sortie de VI. Affectation systématique de la date de dernière modification

:q [ ! ] sortie sans sauvegarde.

! force l'exécution de la commande qui précède, :q! permet de quitter vi sans tenir compte des modifications effectuées.

Commandes de déplacement et positionnement

Les déplacements du curseur sans défilement de l'écran

[nb]↑ ou [nb]k ou [nb]^P même colonne nb lignes avant

[nb]↓ ou [nb]j ou [nb]^N même colonne nb lignes après

[nb]← ou [nb]h ou [nb]<bs> nb caractères précédent sur la même ligne

[nb]→ ou [nb]l ou[nb]<espace> nb caractères suivant sur la même ligne

[nb] 1er caractère nb lignes avant

[nb]+ ou [nb]backspace 1er caractère nb lignes après

[nb]$ dernier caractère de la ligne courante + nb

[nb] | colonne nb de la ligne

0 (zéro) premier caractère de la ligne

^ premier caractère du premier mot de la ligne

[nb]w début du nbème mot suivant ou ponctuation

[nb]W début du nbème mot suivant, déterminé par un espace, une tabulation ou une nouvelle ligne

[nb]b début du nbème mot précédent ou ponctuation

[nb]B début du nbème mot précédent, déterminé par un espace, une tabulation ou une nouvelle ligne

[nb]e fin du nbème mot après le mot courant

[nb]E fin du nbème mot après le mot courant, déterminé par un espace, une tabulation ou une nouvelle ligne

[nb]G ou :nb aller à la ligne nb


Les déplacements du curseur avec défilement de l'écran

[nb]^D Déplacement du curseur nb lignes plus bas et défilement de l'écran vers le haut, Down

[nb]^U Déplacement du curseur nb lignes plus haut et défilement de l'écran vers le bas, Up

[nb]^F Déplacement du curseur nb pages plus bas et défilement de l'écran vers le haut, aFter

[nb]^B Déplacement du curseur nb pages plus haut et défilement de l'écran vers le bas, Before

Les déplacements contextuels du curseur

[nb]( Déplacement du curseur au début de la nb ème phrase précédente. Délimitée par . ! ou ? suivi de 2 espaces

[nb]) Déplacement du curseur au début de la nb ème phrase suivante. Délimitée par . ! ou ? suivi de 2 espaces

[nb]{ Déplacement du curseur au début du nb ème paragraphe précédent.

[nb]} Déplacement du curseur au début du nb ème paragraphe suivant.

% Déplacement sur le caractère parenthèse ou accolade correspondant ( ouvrant / fermant )

H Déplacement en haut à gauche de la page écran (Home)

M Déplacement au début de la ligne centrale de la page écran (Middle)

L Déplacement en bas à gauche de la page écran (Last)

Pose de marque et déplacement sur une marque

m<az> Marque la position courante du curseur avec la lettre donnée. Par exemple, mf positionne la marque f à la position courante

'<az> Place le curseur au début de la ligne correspondant à la marque indiquée (une lettre)

`<az> Place le curseur sur la marque indiquée (une lettre)


Positionnement par recherche de caractère ou de chaîne

[nb]f<car> Recherche de la nb ème occurrence suivante du caractère <car> spécifié

[nb]F<car> Recherche de la nb ème occurrence précédente du caractère <car> spécifié

; Répétition de la dernière commande f ou F dans le même sens

, Répétition de la dernière commande f ou F dans le sens inverse

/<chaîne>/ Recherche de l'occurrence suivante de la chaîne spécifiée. Si aucune chaîne n'est donnée, la dernière chaîne est recherchée

?<chaîne>? Recherche de l'occurrence précédente de la chaîne spécifiée. Si aucune chaîne n'est donnée, la dernière chaîne est recherchée

n Répétition de la dernière recherche de chaîne dans le même sens

N Répétition de la dernière recherche de chaîne dans le sens inverse

Commandes de modification

Passage en mode insertion de texte

a Insertion après le caractère courant

A Insertion après la fin de la ligne courante

i Insertion avant le caractère courant

I Insertion avant le premier caractère significatif de la ligne

o Ajout d'une ligne vide après la ligne courante et passage en mode insertion sur cette ligne

O Ajout d'une ligne vide avant la ligne courante et passage en mode insertion sur cette ligne

Un appui sur la touche <Esc> permet de revenir en mode commande, et donc de quitter le mode insertion.


Suppression de texte

[nb]x Suppression de nb caractères suivants à partir du caractère courant

[nb]X Suppression de nb caractères précédents à partir du caractère courant

D Suppression du reste de la ligne à partir du caractère courant

[nb]dw Suppression de nb mots à partir du caractère courant

[nb]dd Suppression de nb lignes à partir de la ligne courante

La dernière suppression est stockée dans un tampon mémoire appelé tampon d'annulation.

Remplacement, substitution de texte, recherche et remplacement

r<car> Remplacement du caractère courant par le caractère <car> spécifié

R Passage en mode remplacement. Sortie de ce mode par appui sur <Esc>

[nb]s Substitution de caractère. Les nb caractères à partir du caractère courant sont remplacés par les caractères saisis. Le dernier caractère à substituer est signalé par $. Sortie de ce mode par appui sur <Esc>

[nb]S Substitution de ligne. Les nb lignes à partir de la ligne courante sont effacées, et l'on passe en mode insertion. Sortie de ce mode par appui sur <Esc>

[nb]cw Substitution de mot. Les nb mots à partir du caractère courant seront remplacés par les caractères saisis. Sortie de ce mode par appui sur <Esc>


Recherche et remplacement d'une chaîne de caractères dans tout le fichier

...

: g/Dieu/s/Anubis/Isis/g

g Recherche globale dans tout le fichier (sinon recherche sur la ligne courante)

/Dieu/ Sélectionner uniquement les lignes contenant Dieu

s substitue

/Anubis/ la chaîne Anubis

/Isis/ par la chaîne Isis

g pour toutes les occurrences trouvées sur la ligne (sinon uniquement la première)

...

:11,20 g/Dieu/s/Anubis/Isis/g

Idem, mais de la ligne 11 jusqu'à la ligne 20 uniquement.

...

: g/Angers/s//Nantes/g

Dans ce cas, la chaîne à remplacer n'est pas définie, c'est la chaîne de sélection qui sera utilisée à la place. En d'autre termes, les occurrences de la chaîne Angers seront remplacées par la chaîne Nantes.

...

:g/Orléans/s/^#//

Ici, toutes les lignes qui contiennent Orléans seront seront décommentées.


Transfert de texte

Le transfert de texte implique un passage par le tampon d'annulation ou par des tampons supplémentaires nommés par une lettre de l'alphabet en minuscule [ az ].

L'utilisation d'une lettre majuscule pour le transfert dans un tampon permet de compléter le contenu d'un tampon existant.

["<az>] [nb]yw Copie dans un tampon de nb mots à partir de la position courante

["<az>] [nb]yy Copie dans un tampon de nb lignes à partir de la ligne courante

["<az>] [nb]p Insertion après la ligne courante de nb fois le contenu du tampon

["<az>] [nb]P Insertion avant la ligne courante de nb fois le contenu du tampon

Pour les commandes cidessus, le tampon d'annulation est utilisé par défaut, sauf si l'on nomme explicitement le tampon avec lequel on souhaite effectuer le transfert, avec "<az>

Tous les tampons sont conservés en cas de changement d'espace de travail dans une même session vi.


Commandes d'entrée / sortie

:r nomfich Insertion après la ligne courante du contenu du fichier nomfich

:nb r nomfich Insertion après la ligne nb du contenu du fichier nomfich

:r !cmd Insertion après la ligne courante du résultat de la commande cmd

:e [!] [nomfich] Chargement d'un fichier sans sortir de vi. Le contenu du fichier remplace le texte de l'espace de travail. Si nomfich n'est pas spécifié, le fichier courant est rechargé

:w Sauvegarde dans le fichier courant

:w [!] nomfich Sauvegarde dans le fichier nomfich. Si le fichier existe déjà, le ! est obligatoire pour écraser le fichier existant

:w>>nomfich Ajout du contenu de l'espace de travail à la fin du fichier nomfich

:n [!] Positionnement dans l'espace de travail suivant si plusieurs fichiers ont été spécifiés au lancement de vi

:n [!] nomfich Positionnement dans l'espace de travail qui contient le fichier nomfich

:rew [!] Retour au premier espace de travail (Premier fichier de la liste passée à vi)

:e # Commutation entre les fichiers

Commandes diverses

:!cmd Exécution de la commande cmd puis appui sur n'importe quelle touche pour revenir à l'environnement vi

:f ou ^G Affichage du statut du fichier chargé dans l'espace de travail

^L Rafraîchissement de l'affichage

. Répétition de la dernière commande de modification ou d'insertion de texte

u Annulation de la dernière commande exécutée

U Annulation de toutes les modifications effectuées sur la ligne depuis le positionnement sur cette ligne

[nb]J Jonction de nb lignes à la ligne courante. Les caractères <newline> sont remplacés par des espaces.


Définition de l'environnement de vi

Il est possible de personnaliser son environnement de travail vi lors de chaque session ou d'enregistrer les différentes options dans un fichier qui sera pris en compte à chaque appel de vi.

la commande set permet de positionner les options d'environnement vi.

Syntaxe générale :

:set opt Active l'option opt

:set noopt Désactive l'option opt

:set opt? Affiche la valeur ou le statut de l'option opt

:set Affiche les options modifiées

:set all Affiche l'ensemble des options

Quelques options utiles

showmode Visualisation du mode de travail sur la ligne de statut

autoindent Indentation automatique, très utilisée en programmation

number Numérotation des lignes

ignorecase Pas de distinction minuscule / majuscule lors des recherches

tabstop Nombre de caractères entre deux tabulations (par défaut 8)

Enregistrement des options

Les options que l'on souhaite utiliser à chaque exécution de vi peuvent être stockées dans un fichier .exrc situé dans le répertoire de connexion de l'utilisateur.

ATTENTION : sous vi, le fichier .exrc ne doit pas contenir de lignes vides, sans quoi chaque lancement de vi sera suivi d'un message d'erreur (sans que cela soit préjudiciable au bon fonctionnement de l'éditeur). Ce problème n'est pas présent avec vim.


D'autres commandes

unix2dos Conversion d'un fichier texte au format DOS

Conversion des caractères ISO standard en caractères DOS étendu.

Cette commande doit être utilisée devant la commande lp si l'on souhaite adresser la requête d'impression dans la file d'attente d'une imprimante connectée derrière un serveur Windows par exemple.

Syntaxe : unix2dos [ nomfich … ]

Résultat de la commande lp droit :

Résultat de la commande unix2dos droit | lp


TP : vi

1. Ouvrir le fichier Edition de votre répertoire d'accueil avec vi :..................................................................................................................................................

2. Le premier Dupont Jean se prénomme en fait JeanJacques. Le premier Dupont Pierre se prénomme en fait JeanPierre. Rechercher la première occurrence de Dupont Jean :

..................................................................................................................................................

3. Déplacezvous sur le n de Jean puis insérer Jacques : ..................................................................................................................................................

4. De la même manière, rechercher Dupont Pierre et insérer Jean après vous être placé sur le 'P' de Pierre :

..................................................................................................................................................

5. Replacezvous en début de fichier :..................................................................................................................................................

6. Chercher le premier Dupont et insérer sur la ligne précédente votre nom et prénom :..................................................................................................................................................

7. Entrer le nom et le prénom de votre voisin après la ligne du dernier Dupont. Déplacezvous dans le fichier sur les différentes occurrences avec les touches 'n' et 'N' :

..................................................................................................................................................

8. Enregistrer les modifications apportées au fichier et sortir de l'éditeur :..................................................................................................................................................


9. Dupont Jean s'appelle en fait MerlinDuval Jean. Recherchez Dupont Jean et changez Dupont par MerlinDuval :

..................................................................................................................................................

..................................................................................................................................................

10. Supprimer la ligne Couteau Jean après l'avoir retrouvée :..................................................................................................................................................

..................................................................................................................................................

11. Changez tous les Dupont en Durand :..................................................................................................................................................

12. Déplacer toutes les lignes contenant Durand en fin de fichier :..................................................................................................................................................

13. Ajouter un second Ben Raf, en dupliquant la ligne existante :..................................................................................................................................................

14. Sans sortir de la session vi, afficher la date et l'heure (pour savoir si c'est l'heure de la pause) :

..................................................................................................................................................

15. Créez un fichier .exrc dans le répertoire de connexion ($HOME), dont le contenu va permettre d'afficher le mode d'édition, les numéros de lignes et de positionner les tabulations tous les 5 caractères :

..................................................................................................................................................

16. Recherche globale avec remplacement : recherchez et remplacez tous les Durand en Dupont :

..................................................................................................................................................

17. Substituez Jean en JeanPaul : ..................................................................................................................................................

18. Substituer Jean en JEAN :..................................................................................................................................................


19. Substituez JEAN en Jean en modifiant le séparateur de l'expression régulière :..................................................................................................................................................

20. Substituez Jean en JeanJean sur tout le texte :..................................................................................................................................................

21. Ajoutez (033) devant chaque numéro (en fin de ligne) commençant par 1,2 ou 3 :..................................................................................................................................................

22. Ajoutez 0 (zéro) à la fin de toutes les lignes qui commencent par F :..................................................................................................................................................


Processus et mécanismes

Les processus

Les processus

On appelle processus l'image d'un fichier programme contenant du code exécutable binaire en cours d'exécution.

La connexion génère un processus, de même que tout programme exécuté.

Un utilisateur peut lancer plusieurs processus simultanément.

Un processus peut être exécuté en avant plan ou en arrière plan (notion de processus background ou tâche de fond).

Processus et mécanismesVersion : 0.6 82

ps Affichage du statut des processus

Syntaxe : ps [ options ]

e Affiche les informations pour tous les processus

u nomuser Affiche les informations pour l'utilisateur spécifié

t tty Affiche les informations pour un tty particulier

f Affiche les informations au format long

Sans option, la commande ps affiche les informations des processus de l'utilisateur présentées sur 4 colonnes qui sont les suivantes :

PID Process ID : identifiant unique d'un processus

TTY Nom du terminal auquel le processus est rattaché

TIME Temps cumulé d'exécution (vu du processeur)

COMMAND Commande qui est à l'origine du processus

Avec l'option -f les informations suivantes sont affichées en plus :

UID User ID : nom du user propriétaire du processus

PPID Parent Process ID : identifiant unique du processus parent

STIME Heure de départ du processus


kill Demande de terminaison d'un processus

Syntaxe : kill [ signal ] PID [ … ]

signalValeur numérique entière correspondant à des signaux envoyés aux processus

15 Terminaison logicielle

2 Interruption (^C)

9 Arrêt inconditionnel

PID Process ID : identificateur du processus à stopper

Sans valeur de signal, la commande kill envoie un signal 15 : Terminaison logicielle au processus spécifié par le PID. Ce signal peut ne pas être pris en compte par le processus, et dans ce cas, il peut être nécessaire d'envoyer un signal 9 : arrêt inconditionnel.

Mis à part root, seul le propriétaire du processus peut faire une demande de terminaison.


time Affichage du temps d'exécution d'un processus

Syntaxe : time cmd

cmd Commande pour laquelle on souhaite obtenir le temps d'exécution

La commande est exécutée normalement puis, le temps d'exécution est alors affiché. Ce temps est donné par trois valeurs :

real Temps écoulé depuis le lancement de la commande

user Temps d'exécution de la commande en mode utilisateur

sys Temps d'exécution de la commande en mode système

Le temps total d'exécution (d'utilisation du processeur) est obtenu en ajoutant les valeurs user et sys.


les processus en arrière plan

& , jobs , bg , fg Gestion des processus en arrière plan

Exécution en arrière plan

Le lancement d'un processus en arrière plan permet de récupérer "la main" juste après avoir lancé le processus.

Il ne faut pas oublier, dans ce cas, de rediriger les sorties générées par le processus.

Syntaxe : cde &

Après validation de la ligne de commande, deux informations sont retournées avant de récupérer le prompt :

1. Le numéro du job lancé en tâche de fond

2. Le numéro du processus (PID)

Outils pour le background (arrière plan)

Les processus lancés en background ou en arrière plan (par l'ajout d'un & derrière la commande) peuvent être gérés par la commande jobs.


jobs –lPermet d'afficher la liste des jobs et leur PID

Les informations retournées par la commande jobs sont les suivantes :

[ n ] numéro de job

+ job le plus récent

job qui précède directement le plus récent

PID numéro du processus

Etat du job (En cours d'exécution, Terminé)

Ligne de commande à l'origine du job

Il est également possible d'intervenir sur un job en tâche de fond pour le passer en avant plan ou au contraire, passer un processus d'avant plan en job (arrière plan).

Commande bg (background) permet de relancer un processus stoppé par CTRL Z ou par l'envoi du signal 17 SigStop

bg [ %numéro ] Permet de relancer un processus stoppé

Commande fg (foreground) permet de ramener en avant plan un job

fg [ %numéro ] Permet de ramener un job en avant plan


Signaux et suppression d'un job (processus)

Il est possible d'envoyer des signaux aux jobs, avec la commande kill, sans pour cela connaître le numéro de processus sur lequel on souhaite intervenir.

Dans ce cas, la syntaxe de la commande kill est la suivante :

kill –signal %numéro

Il existe plusieurs possibilités pour indiquer à la commande kill le processus concerné :

%n où n correspond au numéro de job entre [ ] affiché par la commande jobs

%% correspond au dernier job lancé

%+ identique à %%

% correspond à l'avant dernier job lancé


priorité des processus

nice

toutes les commandes et processus en cours d'exécution possèdent un niveau de priorité, allant de 20 à +19. Le niveau de priorité le plus fort est 20, le plus faible +19. Le niveau d'exécution est hérité de celui du parent, normalement le niveau zéro.

La commande nice permet d'exécuter une commande avec un niveau de priorité différent de zéro.

Seul l'utilisateur root peut lancer une commande avec un niveau de priorité négatif, c'est à dire supérieur à la normale. Les utilisateurs peuvent seulement exécuter une tâche avec un niveau de priorité plus faible, d'où le nom de la commande.

syntaxe : nice [options] [commande [arguments]]

Sans options ni argument, renvoie le niveau de priorité du shell en cours

nice

Exécuté monscript.sh avec le niveau de priorité +10

nice monscript.sh

Diminuer le niveau de priorité à +5

nice -5 monscript.sh

Augmenter le niveau de priorité à 5 (root seulement)

nice -n -5 monscript.sh

pour vérifier, ici sur une machine Linux

ps -eo pid,ni,user,args


renice

Permet de modifier la priorité d'une tâche en cours d'exécution. Hormis root, les usagers peuvent modifier seulement les processus dont ils sont propriétaires.

La commande renice comprend plus d'options car il est possible d'agir par numéro de processus, par utilisateur propriétaire ou par groupe propriétaire.

syntaxe renice priorité [[p] processID ...] [[g] processGROUP ...] [[u] user ...]

g pour agir sur les process appartenant au groupe

u pour agir sur les process appartenant à l'usager

p pour préciser un numéro de processus sur lequel agir (par défaut si aucune option n'est précisée pour un paramètre)

Changer la priorité des processus d'identificateurs 987 et 32, et tous les processus appartenant aux usagers daemon et root

renice +1 987 -u daemon root -p 32

Noter dans l'exemple l'utilisation du signe + indiquant le niveau de priorité, ce qui n'est pas possible avec nice.

Nota : les commandes nice et renice affectent les valeurs en absolu


redirections

UNIX travaille à partir de flux (suite non formatée d'octets). L'entrée d'une commande est traitée comme un flux, de même que le résultat et les éventuelles erreurs.

Pour chaque commande, il existe trois flux :

0 stdin flux d'entrée standard (clavier)

1 stdout flux de sortie standard (écran)

2 stderr flux de sortie erreur (écran)

Ces trois flux peuvent être redirigés vers ou à partir de fichiers.

Redirection du flux de sortie

> fichier Redirection du flux de sortie standard vers un fichier avec écrasement du fichier si existant.

>> fichier Redirection du flux de sortie standard vers un fichier en ajoutant en fin de fichier.


Commande

EntréeStandard

SortieStandard

SortieErreur

stdin : 0clavier

stdout : 1écran

stderr : 2écran

Redirection du flux de sortie erreur

2>fichier Redirection du flux de sortie erreur vers un fichier

2>&1 Possibilité de rediriger le flux erreur dans le même fichier de redirection du flux de sortie standard.

Redirection du flux d'entrée

< fichier Remplacement de l'entrée standard (clavier) par le contenu de "nom fichier".


pipelines

Les tubes

Un tube permet d'établir une liaison entre deux commandes. La sortie (le résultat) de la première devient l'entrée de la deuxième. Les tubes permettent de combiner les possibilités de plusieurs commandes et de les enchaîner de manière dépendante.

Le mécanisme des tubes permet entre autre chose de combiner les possibilités de commandes différentes.

Dans la formulation d'une commande, le tube est symbolisé par le caractère |

Un tube (pipe) est un canal unidirectionnel qui relie la sortie standard d'une commande à l'entrée d'une autre commande.

Pour afficher le nombre de fichiers standards du répertoire /etc qui finissent par .conf :

ls -l /etc | grep "^-" | grep "\.conf$" | wc -l


commande 1 commande 2

stdout stdin

tee Redirection double en sortie

La commande tee permet de rediriger le résultat d'une commande tout en conservant la sortie standard.

L'association de l'option –a à la commande tee permet d'ajouter à la fin du fichier spécifié.

Dans l'exemple suivant, le résultat de la commande who sera dirigé dans le fichier resultat.txt mais aussi affiché à l'écran :

who | tee resultat.txt


Commande

écran

fichier

tee

TP : Redirections d'entrées/sorties

1. Lister les processus qui finissent par un d. Le résultat sera stocké dans $HOME/process/daemons.txt :

..................................................................................................................................................

2. Rechercher les fichiers dont le nom se termine par .conf à partir de la racine. Cette recherche ne devra être effectuée que sur le système de fichier racine. Le résultat sera affiché à l'écran tout en étant stocké dans le fichier $HOME/resultats/fichiers.conf :

..................................................................................................................................................

3. La commande précédente à duré un certain temps, comment connaître le temps exact d"exécution de celleci ?

..................................................................................................................................................

4. En une commande, renvoyer dans le fichier $HOME/resultats/compteur.txt le nombre de fichiers trouvés dans la commande précédente. Le résultat devra comporter uniquement ce nombre (ce résultat sera réutilisé dans des scripts) :

..................................................................................................................................................


Les droits d'accès

Un fichier appartient à un user et à un group. Les droits d'accès à un fichier sont déterminées en fonction du user et du group propriétaire du fichier.

Gestion des Permissions

Chaque fichier ou répertoire est créé avec des permissions positionnées par défaut par rapport à la valeur du "umask".

Si la lecture des permissions sur un fichier permet de déterminer directement les accès possibles sur celuici, il faut interpréter les permissions sur un répertoire pour déterminer les droits d'accès de ce dernier.

Interprétation des droits sur un répertoire

Droit d'accès Fichier Répertoire

r lecture Visibilité du contenu du répertoire.

Nécessaire pour la commande ls et pour l'utilisation des modèles de critère de recherche sur les noms de fichier

w écriture Possibilité de créer ou supprimer des fichiers ou des répertoires dans le répertoire concerné.

x exécution Possibilité de positionnement dans le répertoire (commande cd)

Le nom du répertoire peut apparaître dans un chemin d'accès

Les droits d'accèsVersion : 0.6 96

chown Changement du user propriétaire

Syntaxe : chown nomuser [ :nomgroup ] nomfich [ … ]

nomuser Nom du nouveau user propriétaire

:nomgroup Nom du nouveau groupe propriétaire

nomfich Nom du fichier pour lequel on souhaite modifier le propriétaire. Ce nom peut être générique

Attention, l'utilisation de la commande chown nécessite une autorisation particulière qui doit être donnée par l'administrateur.

A défaut de ce privilège, seul le groupe propriétaire peut être modifié par le user propriétaire avec la commande chgrp.

L'administrateur (root) est, par défaut, le seul à pouvoir utiliser la commande chown.

Modification avec privilège :


chgrp Changement de groupe propriétaire

Syntaxe : chgrp [ R ] nomgroup [ nomfich | nomrep ] [ … ]

nomgroup Nom du nouveau groupe propriétaire. Ce groupe doit être l'un des groupes dont le user est membre.

nomfich Nom du fichier pour lequel on souhaite modifier le groupe propriétaire. Ce nom peut être générique.

ou

nomrep Nom du répertoire pour lequel on souhaite modifier le groupe propriétaire. Ce nom peut être générique.

-R Modification récursive du groupe propriétaire pour un ou plusieurs répertoires.

Attention, seuls le propriétaire du fichier ou répertoire et root peuvent modifier le groupe propriétaire.


newgrp Modification du groupe connexion

Syntaxe : newgrp nomgroup

nomgroup Nom du nouveau groupe par défaut. Ce groupe doit être l'un des groupes dont le user est membre.


umask Gestion du masque de droits par défaut

Syntaxe : umask [ S ] [ masque ]

masque La valeur du masque peut être passée en mode absolu (valeur octale) ou en mode symbolique (chaîne de caractères).

S Permet de visualiser la valeur du masque en mode symbolique

Si masque n'est pas spécifié, la commande umask [S] retourne la valeur actuelle du masque en octal ou symbolique.

Lors de la création d'un fichier ou répertoire, des droits par défaut sont positionnés. Ils sont déterminés par la valeur du masque retranchée à la valeur maximum des droits.

La valeur maximum des droits d'un fichier est en octal "666" ou en symbolique "r w ". Le droit d'exécution ne peut pas être positionné par défaut à la création du fichier.

La valeur maximum des droits d'un répertoire est en octal "777" ou en symbolique "r w x".

Ces droits (fichiers et répertoires) sont décomposés en 3 groupes de 3 positions. Chaque position a une signification précise (et ce pour les 3 groupes) :

Position 1 droit de lecture

Position 2 droit d'écriture

Position 3 droit d'exécution

Toutes positions le tiret ( ) indique que le droit pour la position n'est pas alloué

Exemple Owner Group owner

Other

Permissions symboliques r w x r x r

Permissions binaires 1 1 1 1 0 1 1 0 0

Permissions octales 7 5 4


chmod Gestion des droits de fichier et répertoire

Les droits d'un fichier ou d'un répertoire peuvent être positionnés en absolu ou en relatif. La première méthode étant plus "dangereuse" car elle implique une prise en compte des droits déjà positionnés.

Modification en absolu

Syntaxe 1 : chmod droits nomfich [ … ]

droits Valeur octale de 3 digits. Chaque digit correspond à un groupe, la valeur de chaque digit correspond aux droits positionnés pour le groupe.

Les valeurs possibles sont :0 aucun droit1 droit d'exécution (x)2 droit d'écriture (w)4 droit de lecture (r)

Ces valeurs peuvent être combinées pour obtenir la valeur octale des droits exacts à positionner.

nomfich Nom du fichier ou répertoire. Ce nom peut être générique.

Modification en relatif

Syntaxe 2 : chmod qui comment quoi nomfich [ … ]

qui Définit pour quel ou quels groupes positionner le ou les droits

Les valeurs possibles sont :u le groupe owner (user propriétaire)g le groupe group ownero le groupe othera tous les groupes (all)

Ces valeurs peuvent être combinées, par exemple go pour définir les droits des groupes group owner et other.


comment Opérateur d'affectation des droits

Les opérateurs possibles sont :+ permet d'ajouter le ou les droits aux droits existants permet de retirer le ou les droits aux droits existants= permet d'assigner les droits spécifiés sans tenir compte

de ceux qui existaient

quoi Le ou les droits à positionner. Les valeurs de base sont :r pour le droit de lecturew pour le droit d'écriturex pour le droit d'exécution

Ces valeurs peuvent être combinées, par exemple rw pour affecter des droits de lecture et écriture.


TP : permissions

1. Créer un fichier Bonjour qui contient les lignes suivantes :

#! /bin/shclearecho "Bonjour $LOGNAME"date "+Nous sommes le %D%nIl est %HH%m"

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

2. Quelles sont les autorisations d'accès qui ont été définies pour ce fichier ?..................................................................................................................................................

3. Quel est l'utilisateur propriétaire, le groupe propriétaire de ces fichiers ?..................................................................................................................................................

4. Pouvezvous exécuter le fichier Bonjour ?..................................................................................................................................................

5. Positionner les droits adéquats pour que le propriétaire puisse exécuter ce fichier :..................................................................................................................................................

6. Supprimer les accès à tous les utilisateurs membres de votre groupe ainsi qu'à tous les autres sur le fichier :

..................................................................................................................................................


Archivage et compressions

Il est indispensable de faire la différence entre l'archivage et la compression, qui correspondent à deux mécanismes différents :

l'archivage

Concaténation d'un ensemble de fichiers et répertoire en un seul fichier. La taille totale n'est pas particulièrement diminuée, l'opération permettant de manipuler un ensemble de fichier ou une arborescence plus facilement lors de manipulations telles que le téléchargement ou l'envoie de mail.

Nous verrons dans le cours la commande tar, mais il faut savoir que la commande cpio est également très utilisée sur les systèmes Unix, même si son usage la réserve particulièrement aux sauvegardes sur bande. rsync est également une commande très intéressante, car elle permet de faire des réplica, et peut fonctionner en mode client/serveur avec le démon rsyncd.

La compression

la compression agit fichier par fichier, son but étant de réduire au maximum la taille des (gros) fichiers pour accélerer les transferts ou minimiser l'espace disque lors des sauvegardes.

L'usage conjoint des deux outils est très courant, car facilitant au maximum la manipulation et le transfert de fichiers sur les liaisons lentes comme internet et la copie des sauvegardes sur les supports de stockage.

Archivage et compressionsVersion : 0.6 104

archiver

tar

Le première argument de tar doit être obligatoirement une de ces lettres: Acdrtux, suivis par n'importe quelles fonctions optionnelles. Les arguments finaux de tar sont les noms des fichiers ou des répertoires qui doivent être archivés. L'utilisation d'un nom de répertoire implique toujours que les sousrépertoires seront inclus dans l'archive.

OPTIONS PRINCIPALES

Il faut obligatoirement utiliser l'une des options suivantes :

A, catenate, concatenate

ajouter des fichiers archives à une archive.

c, create

créer une nouvelle archive.

d, diff, compare

trouver les différence entre une archive et les fichiers indiqués.

delete

supprimer des fichiers d'une archive. (à ne pas utiliser avec les lecteurs de bandes!)

r, append

ajouter des fichiers à la fin d'une archive.

t, list

liste le contenu d'une archive.

u, update

ajoute seulement les fichiers qui sont plus récents que ceux de l'archive.

x, extract, get restaure les fichiers contenus dans une archive.


OPTIONS ADDITIONNELLES

atimepreserve

ne modifie pas les dates d'accés des fichiers de l'archive.

C, directory DIR

aller dans le répertoire DIR.

f, file [HOSTNAME:]F

utilise le fichier archive F ou le périphérique F (par defaut /dev/rmt0).

ignorefailedread

n'abandonne pas l'opération si un fichier est illisible.

m, modificationtime

ne restaure pas la date de modification du fichier.

N, afterdate DATE, newer DATE

enregistre seulement les fichiers plus récent que DATE.

p, samepermissions, preservepermissions

restaure toutes les informations de protection.

P, absolutepaths

n'enlève pas les '/' au début des noms des fichiers.

preserve

comme p s

sameowner

conserve les appartenances des fichiers restaurés.

exclude FILE

exclut le fichier FILE du traitement.

X, excludefrom FILE

exclut du traitement les fichiers dont les noms sont contenus dans FILE.

z, gzip, ungzip

pour les distribution Linux, compresse l'archive avec gzip.


D'autres options existent, notament pour le traitement sur lecteur de bandes de sauvegardes.

Sauvegarder /etc dans une archive etc.tar de mon répertoire d'accueil :

tar cvf ~/etc.tar /etc

lister le contenu de l'archive

tar tvf ~/etc.tar

restaurer l'archive créée dans le répertoire existant repTest

tar xvf ~/etc.tar -C ~/repTest

restaurer uniquement le fichier hosts de l'archive dans son répertoire d'accueil

tar xvf ~/etc.tar -C ~ ./etc/hosts

Noter que le répertoire etc devra être restauré également

le signe – peutêtre utilisé pour remplacer le fichier d'entrée ou de sortie par un pipeline :

tar cvf - . | gzip > /tmp/home.tar.gz

dans le cas présent, l'utilisateur archive son répertoire d'accueil puis compresse cette archive dans /tmp/home.tar.gz

Noter que les distributions linux possèdent une commande tar améliorée qui permet d'invoquer les outils de compression plus aisément.


compresser

compress, gzip Compression de fichiers de données

compress permet de réduire la taille d'un ou plusieurs fichiers. Le résultat de la compression remplace le fichier origine pour lequel le nom est modifié : ajout du suffixe .Z

Syntaxe : compress [ f ] [ v ] [ nomfich …]

f Force la compression si un fichier .Z existe déjà

v Affiche le pourcentage de compression de chaque fichier

nomfich nom du ou des fichiers à compresser. Ce nom peut être générique


gzip permet également de réduire la taille d'un ou plusieurs fichiers ordinaires. L'extension .gz est ajoutée aux fichiers compressés.

Syntaxe : gzip [ f ] [ l ] [ nomfich … ]

f Force la compression si un fichier .gz existe déjà

l Affiche le pourcentage de compression de chaque fichier

nomfich nom du ou des fichiers à compresser. Ce nom peut être générique


uncompress, zcat, gunzip, gzcat Décompression de fichiers .Z, .gz

uncompress permet de retrouver le ou les fichiers originaux à partir d'un .Z

zcat a un fonctionnement identique à uncompress c

Syntaxe : uncompress [ c ] [ nomfich.Z …]

zcat [ nomfich.Z …]

c Permet d'écrire sur la sortie standard, donc pas de destruction du fichier compressé

nomfich.Z nom du ou des fichiers à décompresser. Ce nom peut être générique


gunzip permet également de retrouver le ou les fichiers originaux à partir d'un .gz

gzcat a un fonctionnement identique à gunzip c

Syntaxe : gunzip [ c ] [ nomfich.gz …]

gzcat [ nomfich.gz …]

c Permet d'écrire sur la sortie standard, donc pas de destruction du fichier compressé

nomfich.gz nom du ou des fichiers à décompresser. Ce nom peut être générique


TP : sauvegardes

1. Réalisez une sauvegarde de votre répertoire personnel dans /tmp, en utilisant votre login pour le nommage du fichier :

..................................................................................................................................................

2. Créez dans votre répertoire d'accueil un nouveau fichier vide, et réalisez une mise à jour de votre archive :

..................................................................................................................................................

..................................................................................................................................................

3. Listez le contenu de votre archive pour vérifier qu'elle contient le nouveau fichier : ..................................................................................................................................................

4. Créez une nouvelle archive de votre répertoire personnel, mais cette foisci en la compressant avec gzip, l'opération devant être réalisée en une seule instruction :

..................................................................................................................................................

5. Dans votre répertoire de connexion, créez le répertoire Restaurations et restaurez votre sauvegarde dans ce répertoire en une seule instruction :

..................................................................................................................................................

6. Créez une nouvelle sauvegarde, non compressée, en excluant ce répertoire :..................................................................................................................................................


Le shell

LE SHELL : interpréteur de commandes

Le shell est un programme permettant les échanges entre le système Unix et l'utilisateur : c'est un interpréteur de commandes d'Unix.

Son utilisation s'étend à la programmation, grâce à la gestion des variables, des boucles, et des flux Entrée / Sortie.

Plusieurs shell sont disponibles sur les systèmes Unix.

Les principaux interpréteurs de commandes

Le Shell considéré le plus ancien est le Bourne Shell (sh), du nom de son créateur Steve Bourne.

Bill Joy créa quand à lui le CShell (csh), incompatible avec le bourne shell, mais permettant le rappel de commande , le contrôles des tâches , et l'utilisation des alias de commandes.

Plus tard, David Korn repris le Bourne Shell en y incluant les fonctionnalités du Cshell. Ce nouvel interpréteur prendra lui aussi le nom de son créateur en s'appelant le korn shell (ksh). C'est le shell le plus utilisé des systèmes Unix commerciaux.

Le projet GNU développera aussi son alternative aux shell existants avec le Bourne Again Shell (bash), conforme comme le ksh à la norme POSIX en y ajoutant quelques extensions. C'est l'interpréteur de commande fournit en standard sur les distributions Linux

Quel shell utiliser dans un programme ?

Le Korn Shell et le Bash ont une compatibilité descendante avec le bourne Shell, aussi, l'écriture d'un script en Bourne Shell assure la meilleure portabilité possible. Il comporte cependant quelques lacunes et certaines fonctionalités font défaut, c'est pourquoi il est possible de lui préférer le Korn Shell ou le Bash.

Nous abordons dans ce cours le sh, le ksh et le bash. Ne serons pas vus le csh, le tcsh, le ash, le dash, ni même le zsh.

Le shellVersion : 0.6 113

Fonctionnement général d'un shell


Affichage du prompt

Lecture de la ligne de commande

Analyse de la ligne lue

le 1er mot est-il une commande interne ?

Lancement de la fonction

Création d'un processus

oui non

L'environnement

Caractéristiques :

• Gestion de variables

• Structures de contrôle

• Commandes internes, propre au shell

Liste des variables : commandes UNIX "set" et "env"

Affectation, affichage, export

Variable PATH doit contenir :

.

$HOME/bin

Chronologie d'exécution d'une commande shell

• Recherche du chemin d'accès

• Création d'un shell fils héritant de l'environnement du père

• Traitement des variables et des métacaractères

• Exécution de la ou des commandes (séquentiellement, groupement, tâche de fond)

• Attente de la fin du processus

• Redirection des sorties (stdout, stderr, tube)


les variables

Deux catégories de variables :

les variables locales, accessibles uniquement dans le shell cou rant

les variables d'environnement, éventuellement définies dans un shell père et accessibles depuis n'importe quel sousshell

Les différents types de variables

En Bourne shell les variables sont uniquement de type caractère. Une variable ne peut pas commencer par un chiffre.

Les autres shell acceptent d'autre types de variables :

• entier

• chaîne de caractères

• tableau d'entiers

• tableau de chaînes de caractères

Affectation

Un nom de variable

• commence par un caractère alphabétique ou un underscore : [azAZ_].

• Les caractères suivants sont alphanumérique ou underscore : [azAZ09_].

Attention à

• Ne jamais mettre d'espaces avant et après le signe '='

• Veiller à protéger les espaces dans le contenu des variables

• une variable non déclarée est considérée comme vide

var_un=valeur

var_deux='un deux trois'

Utilisation de la valeur stockée

echo $var_un

echo $var_deux


echo $var_trois

Destruction d'une variable

unset nomvar

Visualisation des variablessetenvtypeset itypeset r

Protéger une variablereadonly var4=30typeset r var5=40

Quelques variables d'environnement

LOGNAME nom du user de connexionMAIL chemin d'accès au fichier boîte aux lettresPATH chemin de recherche des exécutablesPS1 prompt du shellPS2 prompt de continuationSHELL shell de connexionTERM type du terminal utiliséHOME répertoire de connexion~ répertoire de connexion

Ces variables peuvent être visualisées par la commande env ou la commande set.

Par convention, le nom des variables d'environnement est en majuscules.

Nota :

Les variables sont revues en détail dans la partie liée au scripting, car certains mécanismes liés aux variables prennent tout leurs sens dans la création de fichiers de commandes.


les alias

Un alias est un synonyme (une abréviation) auquel on peut associer une commande avec ou sans arguments. Il peut être défini en ligne de commande, dans ce cas, sa durée de vie est équivalente à la durée de la session.

Il peut aussi être défini dans un fichier d'initialisation d'environnement ( .profile ou .kshrc), ce qui en garantit l'existence et la possibilité d'utilisation d'une session à une autre.

alias Définition d'un alias

alias nom='texte'

Le nom de l'alias ne peut comporter que des lettres et des chiffres, aucun caractère spécial.

La substitution de l'alias par sa définition est effectuée avant toutes autres substitutions sur la ligne de commande et ce, uniquement si le nom de l'alias correspond au premier mot de la ligne de commande.

D'autres substitutions peuvent être effectuées si la définition du premier alias se termine par un espace.


Liste des alias définis

alias sans argument


unalias Suppression d'un alias

unalias nom [ nom … ]


le rappel de commandes et la gestion de l'historique

En KSH

Le Korn shell offre la possibilité de travailler avec un fichier historique des commandes saisies et exécutées.

Par défaut, les 128 dernières commandes sont stockées dans le fichier $HOME/.sh_history. Il est possible de modifier le nombre des commandes à conserver dans ce fichier, sans toutefois dépasser le maximum fixé à 32767, en affectant la valeur à la variable HISTSIZE, ainsi que le nom du fichier historique en valorisant la variable HISTFILE.

Le contenu du fichier historique est géré par la commande fc

Affichage des commandes du fichier historique

fc –l affiche les 16 dernières lignes de commandes précédées de leurs numéros

fc –ln affiche les 16 dernières lignes de commandes sans les numéros


Modification d'une commande pour réexécution

L'utilisation de l'option –s de la commande fc permet de substituer un mot par un autre et de réexécuter la commande ainsi modifiée.

Autre possibilité de modification de commande du fichier historique

Le principe consiste à se positionner sur la ligne à modifier et à utiliser les commandes de l'éditeur vi pour effectuer les modifications souhaitées.

<ESC> Passage en mode édition de ligne

k ou Remonte de ligne en ligne dans l'historique

j ou + Descend de ligne en ligne dans l'historique

l ou espace Déplace le curseur vers la droite caractère par caractère

h ou backspace Déplace le curseur vers la gauche caractère par caractère

w Déplace le curseur vers la droite mot par mot

a Insertion de texte à droite du curseur

A Insertion de texte à la fin de la ligne de commande

i Insertion de texte à gauche du curseur

La sortie du mode insertion est faite par appui sur <ESC>.

x Suppression du caractère courant

r Remplacement du caractère courant

etc

La plupart des commandes de l'éditeur vi pourront ainsi être utilisées.


Transfert de lignes du fichier historique vers un fichier

L'utilisation de l'historique des commandes en Korn shell permet également de créer des fichiers (scripts) à partir de lignes de commandes déjà exécutées et donc testées.

Dans ce cas, il ne faut pas oublier l'option –n de la commande fc qui permet de supprimer les numéros de lignes.

Le fichier ainsi créé peut ensuite être modifié par l'éditeur vi et être exécuté de la même manière que les autres fichiers (après positionnement du droit d'exécution x).


en bash

Les facilités offertes par le rappel des commandes et l'autocomplétion dans un shell tel que le bash lui procure un rendement très intéressant, à tel point qu'il est bien souvent plus efficace de se déplacer et d'exécuter des commandes dans un terminal plutôt que par le biais d'une interface graphique.

historique et rappel de commandes

↑ rappeller les commandes précédentes, on peut remonter dans tout l'historique des commandes

↓ rechercher dans l'ordre inverse

!! rappeler la dernière commande exécutée

!com rappeler la dernière commande exécutée commençant par la chaine "com"

!?fich rappeler la dernière commande exécutée contenant la chaine "fich"

history comme en ksh, afficher les commandes mémorisées

!287 rappelle la commande numérotée 287

Après examen de ses possibilités, des questions peuvent se poser, comme :

• Même après avoir fermé sa session ou même redémarré l'ordinateur le rappel de commandes reste disponible pour les utilisateurs, c'est donc que les commandes déjà saisies sont stockées dans un fichier. Quel est donc ce fichier ?

• Combien de commandes sont mémorisées ?

• Quel sont les paramètres passés au rappel de commande ?

Les réponses se trouvent dans des variables :


$HISTCMD contient le dernier numéro de commande utilisé

$HISTFILE chemin et le nom du fichier de rappel

$HISTFILESIZE taille du nombre de rappels possibles

$HISTSIZE taille du nombre de commandes en mémoire

$HISTCONTROL liste des options au rappel de commande ignoreboth : ignorer les doublons de commandes

$HISTTIMEFORMAT N'est généralement pas présente par défaut, il permet d'horodater les commandes saisies.

On pourra par exemple pour le compte root, par mesure de sécurité, passer dans le .bashrc la déclaration de la variable comme ceci :export HISTTIMEFORMAT="%Y/%m/%d @ %T"

autocomplétion

Le bash permet la complétion automatique, c'est à dire l'incrémentation automatique des noms lors de la frappe. L'autocomplétion est activée en pressant une ou deux fois la touche Tabulation.

l'autocomplétion agit sur plusieurs niveaux :

les chemins d'accès

L'autocomplétion est très utilisée pour les chemins d'accès

ls /e

suivi de la touche tabulation se verra autocompléter le chemin /etc :

ls /etc

si l'autocomplétion n'agit pas, c'est que le chemin fournit permet plusieurs possiblités, on pourra alors presser la touche Tabulation deux fois de suite pour afficher les différentes options possibles

ls /etc/h

suivi d'une double frappe sur la touche tabulation pourra donner ceci :

hdparm.conf host.conf hostname hosts hosts.allow hosts.deny


Les commandes

les commandes bénéficient également de l'autocomplétion :

fir

suivi de la touche tabulation donnera :

firefox

Les variables

Même chose pour les variables :

echo $LO

donnera :

echo $LOGNAME

Nota : certains environnements étendent l'autocomplétion encore plus loin, par exemple aux pages de man ou aux options sur certaines commandes.


Les scripts

Créer des scripts

Les scripts shell sont des fichiers de texte dans lesquels sont stockées des suites de lignes de commandes. Ces fichiers peuvent être créés et modifiés par l'éditeur de texte vi.

Particularités des scripts Bourne shell

Une ligne de commentaire commence par le caractère # . Ce même caractère peut être placé derrière le dernier élément d'une ligne à condition qu'il soit précédé d'au moins un espace.

Tout utilisateur dont le shell de connexion est le Bourne shell possède normalement un fichier .profile, script qui est exécuté automatiquement à l'ouverture de session.

# @(#) profile 23.3 91/10/24

#

# Copyright © 1989-1991 The Santa Cruz Operation, Inc.

# All Rights Reserved.

# The information in this file is provided for the exclusive use of the licensees of The Santa Cruz Operation, Inc. Such users have the right to use, modify, and incorporate this code into other products for purposes authorized by the license agreement provided they include this notice and the associated copyright notice with any such product. The information in this file is provided "AS IS" without warranty.

# .profile -- Commands executed by a login Bourne shell

PATH=$PATH:$HOME/bin:. # set command search path

MAIL=/usr/spool/mail/`logname` # mailbox location

export PATH MAIL

Les scriptsVersion : 0.6 128

# use default system file creation mask

eval `tset -m ansi:ansi -m :\?${TERM:-ansi} -r -s -Q`

/usr/bin/prwarn # issue a warning if password due to expire


Les variables dans les scripts

Les variables sont des éléments vitaux dans la réalisation de scripts, il est important de bien comprendre les mécanismes qui les régissent.

Modification du contenu d'une variable d'environnement

NOMVAR=valeurexport NOMVAR la variable "exportée" est alors visible à tous les niveaux

Les variables réservées

$ numéro du processus en cours

? code retour ( 0 si vrai, différent de 0 si faux )

exit 2 provoque la sortie avec le code retour "2"→

! numéro du dernier processus lancé en arrière plan

# nombre de paramètres reçus par le script

1 à 9 paramètres de la commande (1 pour le premier, 2 pour le deuxième, etc)

0 nom de la commande ou du script

@ ou * valeurs des paramètres reçus encadrés par " ". Certaines versions Unix concatènent les valeurs avec *

Exemple :

monscript valun valdeux valtrois

Dans cet exemple les variables suivantes sont affectées :

$# 3 trois paramètres reçus$0 monscript$1 valun$2 valdeux$3 valtrois$@ valun valdeux valtrois


Décalage des paramètres

Le décalage des paramètres se fait, comme en Bourne shell, avec la commande interne :

shift [n]

Après l'exécution de la commande shift :

• $0 inchangé

• $1 perdu

• Deuxième paramètre devient premier paramètre ($1)

• Troisième paramètre devient deuxième paramètre ($2)

• …

• Paramètre n devient paramètre n1

• $# et $* sont REMIS à jour

Possibilité de décaler de n positions (exemple : shift 2 permet de décaler de 2 positions)

Commande set

la commande set permet d'affecter les variables réservées

set $LOGNAME `uname -n`

echo $1 $2

serveur102 user20

cas pratique : modifier son prompt principal

Affichage du prompt avec le nom de chemin du répertoire courant

Modifier le fichier .profile en ajoutant la ligne :

$ PS1='${PWD#$HOME/}(!):'

\d pour ajouter la date (format anglais)

\t pour ajouter l'heure (HH:MM:SS)

\u pour ajouter le nom de l'utilisateur

\r pour un retour à la ligne

\w pour ajouter le chemin complet du répertoire courant

\W pour ajouter le répertoire courant

\h pour ajouter le nom de la machine


Les caractères spéciaux du shell

; Enchaînement systématique de commandes sur une même ligne.

&& Enchaînement conditionnel de commandes : la deuxième commande n'est exécutée que si la première s'est bien passée. (ET)

| | Enchaînement conditionnel de commandes : la deuxième commande n'est exécutée que si la première ne s'est pas bien passée. (OU)

Le regroupement de commandes :

Le regroupement de commande pourra être utilisé pour

– rediriger le résultat de plusieurs commandes vers un fichier ou un tube.

– exécuter plusieurs commandes dans un même environnement.

(cmd1; cmd2; cmd3 ) Création de sous shell dans une commande.

Renvoyer le nombre total de fichier contenu dans /bin et /usr/bin :

(ls /bin/; ls /usr/bin) | wc -l

{ cmd1; cmd2; cmd3; } Regroupement de commandes sans création de sous shell.

Attention, respecter le point virgule suivant le dernière commande et les espaces après et avant les accolades

{ ls /bin/; ls /usr/bin; } | wc -l


Utiliser les couleurs dans le prompt

Il est possible d'utiliser quelques couleurs dans le shell. Il pourra être utile de les utiliser pour l'affichage à l'écran d'informations importante, ou dans le prompt de l'utilisateur.

Couleur Caractères Fond Attribut des caractères

Noir 30 40 0 : aucun

Rouge 31 41 1 : gras

Vert 32 42 4 : souligné

Brun 33 43 7 : inversé

Bleu 34 44 8 : invisible

Magenta 35 45 9 : barré

Cyan 36 46

Blanc 37 47

➔ Pour annoncer la couleur : \033[

➔ Pour finir la définition de couleur : m

➔ Pour remettre la valeur initiale : \033[0m

exemple :

$ echo -e "voici du \033[1;32mvert\033[0m


Les commandes internes au shell

read Lecture au clavier et stockage des caractères saisis dans la ou les variables spécifiées, utilisé dans les scripts pour capturer une saisie clavier

$ echo "Veuillez entrer votre nom : "

$ read nom

$ echo "Bonjour $nom"

En ksh un syntaxe alternative est disponible :

$ read nom?"Veuillez entre votre nom : "

echo Affichage écran

$ echo expression

Si expression contient des caractères spéciaux, il faut la protéger avec des quotes.

\c inhibe le changement de ligne en fin de commande echo

\n nouvelle ligne

\t tabulation horizontale

\\ le caractère \

Note : en bash, il faudra utiliser le paramètre "e" pour prendre en compte les caractères spéciaux

exec Exécution d'une commande externe sans création de sousshell. ATTENTION : à la fin de la commande, le shell père est tué.

exec cmd

cd Changement de répertoire. ATTENTION : les changements de répertoires effectués dans un sousshell sont ignorés du shell père.

exit Sortie du shell (script)

exit [ n ] n est la valeur retournée au shell père dans la variable ?


shift Glissement des paramètres. Supprime la valeur du premier paramètre et décale toutes les autres valeurs vers la gauche.

shift [ n ] n : valeur entière correspondant au pas de décalage

Après chaque décalage, les valeurs des variables #, @ et * sont remises à jour.

expr Calcul arithmétique. Si une variable est spécifiée, son contenu doit être numérique.

expr expression

Chaque opérateur doit être précédé et suivi d'un espace.

$ expr 2 + 7

$ expr 2 \* 7

nota : les commandes let et (( .... )) remplacent avantageusement expr, nous les étudions au chapitre "L'arithmétique entière"


les conditions (test, if, case)

test Evaluation de condition

test condition

[ condition ] La condition doit être précédée et suivie d'un espace

Éléments de la condition :

Opérateurs entiers :eq égaliténe différencegt supérieurge supérieur ou égallt inférieurle inférieur ou égal

Opérateurs chaîne :

= égalité!= différencen nomvar variable non nullez nomvar variable nulle

Opérateurs de fichiers :d nomfich répertoiref nomfich fichier ordinairep nomfich tube nomméc nomfich périphérique caractèreb nomfich périphérique blocw nomfich droit d'écriturer nomfich droit de lecturex nomfich droit d'exécutions nomfich taille de nomfich > 0

Combinaisons :

a et ( laisser un espace autour de a et de o)o ou! négation( ) regroupement ( à isoler par des antislashs ex : $ ........ $


break Dans une structure répétitive, permet de sortir de la structure.

continue Dans une structure répétitive, permet de retourner à la condition.

Enrichissement de la commande test : [[…]]

Cette syntaxe permet l'utilisation des caractères spéciaux pour la comparaison de chaînes :

* 0 à n caractères

? 1 caractère quelconque

[…] 1 caractère parmi ceux entre crochets

[!...] 1 caractère n'étant pas entre crochets

Pour les caractères suivant, s'assurer que l'option extglob est activée

$ shopt

$ shopt -s extglob

?(...) 0 à 1 fois l'expression

*(...) 0 à n fois l'expression

+(...) 1 à n fois l'expression

@(...) 1 fois l'expression

!(...) 0 fois l'expression

*(...|...) De 0 à n fois l'expression 1 ou l'expression 2

valables également pour les caractères ? * + @ !

Exemple :

$ var=+123

$ [[ $var = ?([+-])+([0-9]) ]] && echo "Le nombre est valide"

var contient un nombre valide

tester avec 123, 132, 123.56


améliorer le test en ajoutant la prise en compte des nombres décimaux

Attention : les opérateurs a et o sont remplacés par && et ||

exemple :

Syntaxe normale

$ [ -f fic1 -a $ -d rep1 -o -d rep2 $ ] && echo OK

Syntaxe avec [[ …. ]]

$ [[ -f fic1 && ( -d rep1 || -d rep2 ) ]] && echo OK


TP : scripting utiliser les éléments base

1. Créer le script "test_var_read.sh" qui :

• prend un nom en argument. Si aucun argument n'est passé il demande la saisie du nom à l'utilisateur.

• si aucun nom n'est saisi, attribue le nom "invité"

• si le nom est "root":

• affiche "Interdit de se connecter en root" en rouge gras sur fond noir

• quitte le script avec le code retour 4

• Affiche : Bonjour <nom>, bienvenue sur la machine <nom_de_la_machine>

• si le nom est invité, affiche : "vous avez été redirigé sur le compte "invité"

• si le nom n'est pas invité, affiche : "Vous vous êtes connecté en <nom>"

• affiche : "Le script s'est correctement déroulé"..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


if else

if condition

then action

[ elif condition

then action ]

[ else action ]

fi

condition peut être exprimée par : test condition ou [ condition ]

action est une instruction ou un ensemble d'instructions

Utilisation des structures imbriquées

if ………

then ………

elif ………

then ………

fi # le fi est commun avec elif

différent de

if ………

then ………

else

if ………

then ………

fi # le fi pour le second if

fi # le fi pour le premier if


read rep

if [ z "$rep" ]

then echo "réponse nulle"

if [ $# eq 0 ]

then echo "Pas de paramètres"

exit

case

case $nomvar in

expr)

action

;;

expr)

action

;;

*)

action

;;

esac

case $var in

p)echo "la lettre est p"

;;

[0-9])

echo "un chiffre"

;;

a|b)

echo "a ou b"

echo "\?"

;;

*)

echo "n'importe quel autre caractère"

;;

esac

Nota : La commande case autorise l'utilisation de la substitution de caractères, même avec les expressions complexes


les boucles (while, until, for)

while

while : tant que

Tant que la condition est remplie, on reste dans la boucle :

while CONDITION

do

ACTIONS

done

Exemple : imposer la saisie du nom à l'usager :

while [ -z "$nom" ]

do

echo -e "Veuillez entrer votre nom : \c"

read nom

done

echo Bonjour $nom

Il est possible de générer des boucles infinies avec le caractère " : ". Dans ce cas, la boucle se répète indéfiniment, on pourra utiliser cettre propriété pour la création de menus par exemple.

while :

do

echo menu

echo "1) copie des fichiers"

echo "2) restauration des fichiers"

echo "q) Quitter"

echo -e "Taper 1, 2 ou q pour continuer : \c"

read choix

case $choix in

1) echo copie des fichiers; read ;;

2) echo restauration des fichier; read ;;

q) exit 0;;

*) saisie incorrecte;;


esac

done

until

until : Jusqu'à ce que

On reste dans la boucle jusqu'à ce que la condition soit remplie

until s'utilise en alternative de la boucle while

until CONDITION

do

ACTIONS

done

exemple :

until [ -n "$age" ]

do

echo -e "Saisissez votre age : \c"

read rep

done


for

La boucle for permet de réaliser des actions en fonction d'une liste de valeurs qui lui est fournie.

for nomvar in LISTE

do

ACTIONS

done

$ for var in 1 2 b toto

>do

>echo "la valeur est : $var"

>done

la valeur est : 1

la valeur est : 2

la valeur est : b

la valeur est : toto

$

Cas particulier de la boucle for :

for (( initialisation de VAR; contrôle de VAR; modification de VAR))

do

ACTIONS

done

Exemple : compte à rebours :

for (( i=10; i>=1; i-=1 ))

do

echo "mise a feu dans $i sec."

sleep 1

done

echo '!!! BOUM !!! '


NOTA: la boucle for utilise la valeur de la variable interne IFS (Internal Field Separator) comme champs de séparation. Il est parfois pratique de modifier cette valeur.

# set | grep ^IFS

IFS=$' \t\n'


TP : scripting les structures de contrôle

1. faire une copie du script "test_var_read.sh" en "if.sh". Modifier le script pour utiliser la structure if elif dans les test.

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


2. Faire une copie de "if.sh" en "case.sh". Modifier le script pour utiliser la structure case à la place de if elif.

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


3. faire un copie du fichier "case.sh" en "while.sh" Modifier le script "while.sh" en obligeant la saisie clavier lorsque aucun argument n'a été fournit :

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


4. Créer le script for.sh qui créé une sauvegarde de tous les fichiers du répertoire courant se terminant par ".sh" :

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


les fonctions

Les fonctions permettent de regrouper plusieurs commandes qui pourront être exécutées de façon régulières durant le script.

Il sera possible de les mettre dans un fichier séparé, permettant un script plus lisible et la possibilité de les réutiliser pour d'autres scripts.

Les fonctions peuvent être invoquées avec des paramètres, comme pour un fichier de script.

Syntaxe de définition d'une fonction

nomfonction()

{

instructions qui composent la fonction pour fournir le résultat recherché

}

Exemple

Définition dans un fichier indépendant :


Intégration du fichier bodyfonc et appel des différentes fonctions définies

Définition de la fonction directement dans le script où elle est référencée

Appel de la fonction

L'appel de la fonction se fait simplement en donnant son nom.

Il est possible de passer des paramètres positionnels à l'appel de la fonction de la même manière que le passage de paramètres lors de l'exécution d'une commande ou d'un script.


TP : scripting les fonctions

1. Créer le script fonctions.sh qui propose de :

• sauvegarder les fichiers du répertoire courant se terminant par .sh avec l'extension .save

• supprimer les fichiers se terminant par .save

• quitter

Un autre fichier fonctions.fonc comportera les fonctions de sauvegarde et de suppression...................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


Des commandes pour les scripts

eval double évaluation

Le mécanisme de substitution est fait par le shell en balayant une fois les commandes et en interprétant les caractères de substitution.

On peut doubler ce passage par la commande eval

Il y a alors évaluation de la commande située derrière eval et ensuite exécution de cette commande. Cela permet, dans certains cas, d'effectuer deux passages de substitution.

Exemple

nom=Martin

var=nom

# Comment afficher le contenu de 'nom' en passant par 'var' ?

echo $var

nom # c'est nom qui s'affiche

echo $$var

2201var # ici, c'est la variable $$ suivi de var

echo ${$var}

${$var} : mauvaise substitution

eval echo \$$var

Martin # ça y est, grâce à la commande eval

Des commandes pour les scripts Version : 0.6 154

trap gérer les signaux

Les signaux renvoyés aux scripts ou au shell courant peuvent être interceptés par la commande trap afin de modifier leur comportement.

Rappel sur les principaux signaux :

Nom N° Usage

HUP 1 Rupture d'un ligne de terminal

relecture du fichier de configuration (pour les daemons)

INT 2 Arrêt prématuré du processus, en général ^C au clavier

TERM 15 Arrêt normal du processus

KILL 9 Arrêt inconditionnel.

Attention : on ne peut pas intercepter ce signal

kill l : affiche la liste de tous les processus

stty a : affiche les paramètres du terminal

syntaxe : trap ' <cmd1> ; <cmd2 >' <signal1> <signal2>

exemples:

faire un ^C renverra le résultat de la commande écho, sans interrompre le programme en cours

$ trap 'echo Ne pas interrompre' INT

ignorer totalement le signal SIGINT

$ trap '' 2

Supprimer les fichiers se terminant par tmp et sortir à la réception du signal INT ou TERM.

$ trap 'rm -f *.tmp ; exit 1' INT TERM

remettre les valeurs par défaut

$ trap 2 15

idem

$ trap – INT TERM


clear effacement écran

Syntaxe : clear

Commande simple sans argument, permettant d'afficher une page écran vierge.


tr suppression, remplacement de caractères

La commande tr agit uniquement caractère par caractère, elle permet de :

Supprimer des caractères

Afficher le fichier Edition sans les a, les b et les c :

$ cat Edition | tr -d abc

Remplacer des caractères par d'autres caractères

Afficher le fichier Edition avec les a, le b et les c remplacés respectivement par des x, des y et des z :

$ cat Edition | tr abc xyz

Afficher tout le contenu du fichier Edition en majuscule :

$ cat Edition | tr "[a-z]" "[A-Z]"

$ cat Editon | tr "[:lower:]" "[:upper:]"

Supprimer les doublons de caractères contigus

Supprimer les doublons des espaces contigus au résultat de la commande who :

$ who | tr -s " "

Afficher le fichier Edition sans lignes vides

$ cat Edition | tr -s "\n"

Explication : une fin de ligne comporte toujours le caractère (non visible) \n. Une ligne vide comporte donc uniquement ce caractère, si bien que la ligne précédente se terminant par un \n est suivi lorsqu'une ligne est vide d'un autre \n.

Combiner ces possibilités

transformer tous les espaces en | (tube) et supprimer les doublons de | (tubes) en sortie de commande who

$ who | tr -s " " "|"


cut Découpage vertical de fichier

Syntaxe : cut c listecols [ nomfichier ]

cut f listechps [ d carsep ] [ s ] [ nomfichier ]

c listcols Spécifie les caractères sélectionnés. La liste de caractères peut être composée d'intervalles ( .... ) et/ou d'énumérations ( .. , .. , .. )

f listchps Spécifie les champs sélectionnés. La liste de champs peut être composée d'intervalles ( .... ) et/ou d'énumérations ( .. , .. , .. ). Un champ est, par défaut, déterminé par une tabulation.

d carsep Spécifie carsep comme séparateur de champs à la place de la tabulation. Si ce caractère est un caractère spécial, il doit être protégé de quotes.

s Utilisé avec l'option f, permet de supprimer les lignes sans caractère séparateur

nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande travaille sur le flux d’entrée.


split Découpage de fichier en blocs de lignes

Syntaxe : split [ nbl ] [ a lgs ] [ nomfichier [ racine ] ]

nbl Nombre de lignes qui compose chaque bloc. Par défaut 1000.

a lgs Nombre de caractères du suffixe. Par défaut 2, composé de lettres : aa, ab, ac, ad…

nomfichier Nom du fichier à traiter. Ce nom peut être générique. A défaut de nom, la commande travaille sur le flux d’entrée, mais dans ce cas, il n'est pas possible de spécifier une racine.

racine Racine utilisée par la commande split pour générer les noms de fichiers. Par défaut la lettre 'x' est utilisée. A cette racine, split ajoute un suffixe composé d'au moins deux lettres.


paste Fusion de lignes de fichiers

Syntaxe : paste [ s ] [ d liste ] nomfich1 nomfich2 …

s Fusion des lignes d'un ou plusieurs fichiers

d liste Liste de séparateurs de champs. Cette liste peut être composée de n'importe quel caractère et de caractères qui seront interprétés tels que :

\n nouvelle ligne \t tabulation

\\ backslash \0 chaîne vide (aucun caractère)

Les caractères sont interprétés les uns après les autres de manière circulaire.

Par défaut, le séparateur est une tabulation.

nomfich1 2 Nom du ou des fichiers à traiter.


sort Tri des lignes de fichiers

Syntaxe : sort [ optcom ] k [ Fdeb [ .Cdeb ] ] [ optionTri ] , [ Ffin [ .Cfin ] ] [ optionTri ] nomfich

sort [ optcom ] [ +Fdebsaut [ .Cdebsaut ] ] [ optionTri ] [ Ffinsaut [ .Cfinsaut ] ] [ optionTri ] nomfich

Options qui modifient le comportement par défaut de la commande sort :

c Contrôle que l'entrée est bien triée

m Fusionne plusieurs fichiers d'entrée s'ils sont déjà triés

u Demande de suppression des valeurs en double dans les critères de tri définis

Options de tri :

optcom Options communes de tri qui seront prises en compte pour tous les critères

optionTri Option propre au critère qui la précèdeb Ignore les espaces situés en début de critèred Tri par ordre du dictionnaire, seuls les lettres, les chiffres et les

espaces sont pris en comptef Transforme les minuscules en majuscules avant la comparaisoni Ignore les caractères non imprimablesn Tri de type numériquer Inverse l'ordre de tri qui par défaut est croissant

Première méthode ( k )

Fdeb Champ de début de critère de tri

.Cdeb Caractère, dans le champ, de début de critère de tri

Ffin Champ de fin de critère de tri

.Cfin Caractère, dans le champ, de fin de critère de tri

Seconde méthode (+ )

Fdebsaut Nombre de champs ignorés. Le début du critère correspond au début du champ suivant

.Cdebsaut Nombre de caractères ignorés dans le champ. Le début du critère correspond au caractère suivant


Ffinsaut Nombre de champs ignorés. La fin du critère correspond au début du champ suivant

.Cfinsaut Nombre de caractères ignorés dans le champ. La fin du critère correspond au caractère suivant

Quelle que soit la méthode utilisée, si le critère de début n'est pas spécifié, il correspond par défaut au début de la ligne, si le critère de fin n'est pas spécifié, il correspond par défaut à la fin de la ligne.

Si aucun critère de tri n'est spécifié, le critère retenu par défaut est la ligne entière.


uniq supprimer les doublons de lignes

uniq permet de supprimer les lignes consécutives en plusieurs exemplaires afin de n'en conserver qu'une. Il est impératif que les lignes se suivent, aussi il faudra prendre soin de trier le fichier si nécessaire.

syntaxe : uniq [ options ] [ fichier1 [ fichier2]]

c chaque ligne est préfixée du nombre d'occurences trouvées

d n'affiche que les lignes en plusieurs exemplaires

u n'affiche que les lignes uniques

s n ignore les n premiers caractères dans la comparaison

w n compare jusqu'à n caractères dans chaque ligne

f n ignore les n premiers champs, délimités par espace ou tabulation

i igrore la casse

Exemple :

$ sort fic1 | uniq


awk Présentation de l'utilitaire

Awk est un utilitaire qui permet de travailler sur le contenu d'un ou plusieurs fichiers.

Il possède des variables internes positionnées à la lecture des lignes. Parmi ces variables, les suivantes sont très intéressantes :

NF nombre de champs de la ligne

NR numéro de la ligne courante dans le fichier

FILENAME nom du fichier ouvert

$n le nième champ de la ligne

Structure du programme

Awk permet d'écrire des programmes complets avec des itératives, tests…

Le programme peut être passé en paramètre (en ligne de commande) à awk, dans ce cas, il sera protégé de quotes.

Il peut aussi être saisi dans un fichier dont le nom sera fourni à awk par l'option –f.

Structure générale :

[ BEGIN { action(s) begin } ]

[ sélection1 ] [ { action(s) 1 } ]

[ sélection2 { action(s) 2 } ]

…

[ END { action(s) end } ]

Si une telle structure est utilisée, le fonctionnement du programme sera le suivant :


avant la lecture du fichier, awk exécute les actions "begin"

pour chaque ligne du fichier, awk évalue les sélections : si la sélection est valide pour la ligne courante, l'action ou les actions sont exécutées.

Si plusieurs sélections sont valides pour une ligne, alors toutes les actions correspondantes seront exécutées.

après lecture complète du fichier, awk exécute les actions "end".

Remarque :

Aucun des éléments de la structure cidessus n'est obligatoire lors de l'écriture d'un programme awk.

La séquence BEGIN { } et / ou la séquence END { } peuvent être absentes.

Si la sélection n'est pas spécifiée, l'action est exécutée pour toutes les lignes du fichier.

Si l'action n'est pas spécifiée, les lignes qui vérifient la sélection sont recopiées sur la sortie standard.

Séparateur de champs

Par défaut, le séparateur de champs est l'espace ou la tabulation.

Il est toutefois possible de le modifier :

avec l'option –Fs associée à la commande awk, où s est le nouveau séparateur

en affectant la variable FS dans la séquence BEGIN { } du programme

Description d'une action

Une action correspond à une séquence de code en langage C. La différence, c'est que awk est interprété (non compilé comme le langage C) ce qui n'oblige pas à déclarer toutes les variables utilisées.

Une variable non déclarée est toujours nulle ou vide à la première utilisation.

Toute constante de chaîne doit être encadrée par des double quotes.

Lors d'une affectation, il est possible de concaténer des champs en les séparant par des espaces.


Fonctions internes

Les fonctions de manipulations de champs et d'impression sont les plus intéressantes, parmi les plus utilisées :

print

Permet d'imprimer un résultat

Chaque fonction print provoque un retour à la ligne

Il est possible d'utiliser la fonction print avec ou sans paramètre (voir les exemples suivants)

printf

Identique à la fonction print avec un formatage de la sortie.

{ printf ( "options formatage" , valeurs à imprimer ) }

Principales options de formatage :

%c 1 caractère

%s 1 tableau de caractères

%nbs chaîne cadrée à gauche

nb longueur de la chaîne, avec complément par espace

%d valeur entière

%nbd valeur entière avec un nombre de positions nb

%f réel

%e.df réel avec :

e nombre d'entiers

. séparateur décimal

d nombre de décimales

sprintf

Identique à la fonction printf avec affectation du résultat à une variable (sans utiliser la sortie standard)

{ vares = sprintf ( " %3d %4.2f " , $1 , $2 ) }


length

Retourne la longueur de la ligne ou d'un champ passé en argument

{ print length($1) } longueur du champ 1

{ print length( ) } longueur de la ligne

index

Retourne la position d'une souschaîne dans la ligne ou dans un champ passé en argument

{ print index($1,"RECH") } position de "RECH" dans le champ 1

match

Identique à index, mais la souschaîne est remplacée par une expression régulière

{ match($1,"[EJ]") } position de "E" ou "J" dans le champ 1

substr

Extraction d'une chaîne à partir d'une position sur une longueur spécifiée

{ substr($1,2,3) } extraction du champ 1 de 3 caractères à partir du deuxième

sub

Substitution d'une chaîne par une autre

{ sub("recherche","remplacement", $1) }substitution de la chaîne "recherche" par la chaîne "remplacement" dans le champ 1

gsub

Identique à sub, mais agit sur toutes les occurrences de la chaîne recherchée

split

Décomposition d'un champ en souschamps (séparés par un caractère spécifié) avec valorisation d'un tableau.


Dans l'exemple cidessus, on décompose la chaîne de caractères en souschamps, séparés par "_", le nombre de souschamps est affecté à une variable n, puis la valeur de chaque souschamp est affichée dans une boucle for (syntaxe du langage C)

toupper, tolower

Conversion en majuscules et en minuscules

{ print toupper( $1 ) } affiche le champ 1 en majuscules

{ print tolower( $1 ) } affiche le champ 1 en minuscules

Pour des applications relativement simples, il est possible de déterminer une liste d'instructions au niveau de la ligne de commande, tel que dans les exemples suivants :

Pour des applications un peu plus complexes, il est conseillé de créer un fichier qui contient les différentes instructions, tel que dans les exemples suivants :

Affichage des lignes pour lesquelles le nombre de champs est > 2 et affichage du premier champ si le troisième champ se termine par 1 ou 4

$ cat progawk

NF > 2 { print $0 }

$3 ~ /[14]$/ { print $1 }

On lance ensuite le programme par la commande :

$ awk –f progawk clients

Impression et calcul d'un total à partir d'un fichier de données :


La section BEGIN permet d'imprimer les entêtes de colonnes et d'initialiser la variable total.

L'action composée de la fonction printf est appliquée à chaque ligne du fichier :

%10s cadrage à gauche du premier champ sur un nombre de positions égal à 10

%7d entier sur 7 positions

\n retour à la ligne

$1,$2 impression des champs 1 et 2

total += $2 cumul du champ 2 dans la variable total

La section END permet d'imprimer la valeur totale obtenue par le cumul

Exemples :

Afficher les champs 1, 2 et 3 du fichier clients lorsque la ligne se termine par 2 ou 3 :

awk '/[23]$/ { print $1, $2, $3 }' clients

Afficher les lignes du fichier clients lorsque le champ 3 commence par 2 ou 3 :

awk '$3 ~ /^[23]/ { print }' clients

Afficher le numéro de ligne et les champs 1 et 2 du fichier clients :

awk '{ print NR , $1 , $2 }' clients


Afficher le nombre de champs de la ligne, le champ 1 et le dernier champ du fichier clients :

awk '{ print NF , $1 , $NF }' clients

Afficher les lignes du fichier clients dont le champ 3 est égal à 222222 :

awk '$3 == "222222" { print }' clients

Il est possible d'utiliser des opérateurs booléens pour exprimer une condition. Ces opérateurs sont les suivants :

&& ET|| OU| NOT

Exemple d'utilisation : afficher les lignes dont le champ 3 est égal à 222222 et dont le champ 2 commence par P :

awk '$3 == "222222" && $2 ~ "^P" {print}' clients

Utiliser les conditions :

Afficher les utilisateurs ayant un UID compris entre 500 et 10 000 :

awk -F":" '{ if ($3 >= 500 && $3 <= 10000) print }' /etc/passwd


TP : scripting les commandes

1. Modifier le script fonctions.sh afin d'en interdire l'interruption par ^C. Un message "Veuillez taper q pour quitter le script" est renvoyé à l'utilisateur dans ce cas.

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

2. Modifier le script fonction.sh afin de toujours afficher le menu en haut de la fenêtre de la console.

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

3. Ajouter un nouvel item au menu en proposant d'afficher les noms et adresses IP de la machine.

Exemple :

nom et adresse IP :eth0 10.11.100.101/16eth1 172.16.5.1/24

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................

..................................................................................................................................................


Plus loin avec les variables

Substitution de variables

Utiliser une variable, si celleci n'est pas définie (ou vide) utiliser une valeur explicite

Afficher la valeur de $nom, si celleci n'est pas définie, afficher 'invité'

$ echo ${nom-invité}

Utiliser le 2eme paramètre, si celui est absent utiliser la valeur 'defaut'

$ user=${2-nobody}

Afficher la valeur de $nom, si celleci n'est pas définie ou vide, afficher 'invité'

$ echo ${nom:-invité}

Utiliser une variable, si celleci n'est pas définie (ou vide), lui affecter une valeur

Afficher la valeur de $nom, si celleci n'est pas défini lui affecter la valeur 'invité'

$ echo ${nom=invité}"

Afficher la valeur de $nom, si celleci n'est pas défini ou vide lui affecter la valeur 'invité'

$ echo "Entrer votre nom :"

$ read nom

$ echo "Bonjour ${nom:=invité}"

Retourner la longueur d'une variable :

$ var=caractères

$ echo ${#var}

10

Plus loin avec les variablesVersion : 0.6 172

Retirer le plus petit fragment à gauche : #

$ var=fic.save

$ echo ${var#??}

c.save

$ echo ${var#*.}

save

Retirer le plus grand fragment à gauche : ##

$ var=/usr/bin/test.sh

$ echo ${var##*/}

test.sh

Retirer le plus petit fragment à droite : %

$ var=fic.save

$ echo ${var%.*}

fic

Retirer le plus grand fragment à droite : %%

$ var=fic.save.save

$ echo ${var%%.*}

fic


L'arithmétique entière

Les commandes let et (( …. )) présentent de nombreux avantages sur la commande expr:• nombre d'opérateurs plus important

• pas besoin de séparer les arguments par des espaces

• les variables n'ont pas besoin d'être invoquées avec le signe $ (mais peuvent l'être)

• il n'est pas nécessaire de protéger les caractères spéciaux du Shell.

• Les affectations peuvent être faites dans la commande

Déclarer une variable de type "entier"

$ typeset -i variable2=20

Lister les variables de type "integer"

$ typeset -i

Les commandes let et (( … )) ne nécessitent pas de déclarer des variables de type entier :

$ let "k=i+j" OU ((k=i+j))

Les opérateurs arithmétiques sont :+ addition soustraction* multiplication/ division% reste de la division (modulo)

Les opérateurs de comparaison sont :<= inférieur ou égal>= supérieur ou égal> strictement supérieur< strictement inférieur== égal!= différent

$ i=15 ; j=10

$ (( i > j )) && echo "i est supéieur à j"


Les opérateurs logiques sont :! négation&& et|| ou

Syntaxe qui permet de savoir si k=i+j et h=k*2 :

Astuce :

la commande (( … )) ne renvoie rien, la syntaxe suivant ne sera donc pas valable :

$ nb=10

$ echo nb vaut `(( nb + 15 ))`

nb vaut

pour avoir l'affichage il faudra utiliser le caractère $ du shell :

$ nb=10

$ echo nb vaut $(( nb + 15 ))

nb vaut 15


les variables de tableau

Classiquement, pour créer puis afficher une variable

$ client=Dupont

$ echo $client

Dupont

Mais nous aurions aussi pu l'afficher en utilisant cette syntaxe :

$ echo ${client}

Dupont

Implicitement, la valeur d'une variable est définie comme étant le premier élément d'une variable de tableau. Pour afficher le premier index d'une variable de tableau :

$ echo ${client[0]}

Dupont

pour afficher le deuxième index d'une variable de tableau:

$ echo ${client[1]}

Aucune erreur n'est renvoyée, en fait, le deuxième index de la variable n'est pas rempli.

$ client[1]=Alexandre

$ echo ${client[1]}

Alexandre

Pour afficher le contenu de la variable entière

$ echo ${client[*]}

Dupont Alexandre

Il est possible de positionner une variable pour spécifier un numéro d'index :

$ prenom=1

$ echo ${client[prenom]}

Alexandre

Afficher le nombre de valeurs que comporte une variable de tableau

$ echo ${#client[*]}

Nota : Les variables de tableau vont de 0 à 1023


TP : scripting scripts de synthèse

1. Classer mes images

étape 1

Créer un script de classement de fichier

année mois jour fichiers→ → →

attention: les dates ne doivent pas être modifiées

étape 2

spécifier les formats de fichiers (*.jpg, *.avi, *.raw)

étape 3

pouvoir afficher/ajouter/supprimer des extensions de fichiers

2. Surveillance de serveurs

Créer un script que l'équipe MCO (maintien en condition opérationnelle) lancera chaque matin.

– espace disque : vérifier que l'espace disponible est supérieur à un seuil

– services : vérifier que les services syslogd et kjournald sont opérationnels (des services doivent pouvoir être ajoutés

– fichiers journaux : afficher les messages significatifs du jour du fichier /var/log/messages

3. Afficher les membres d'un groupe donné

Créer un fichier script members.sh qui permet d'afficher les membres d'un groupe donné en argument ou par saisie clavier. Attention au


Index des commandes

Aalias 119awk 164

Bbg 86

Ccal 19case 141cat 48cd 31chgrp 98chmod 101chown 97clear 156cmp 54compress 108cp 39cut 158

Ddate 18diff 55

Eeval 154

Ffg 86file 42find 65for 144

Ggrep 64gunzip 110gzcat 110gzip 108

Hhead 51

Iid 14if 140

Jjobs 86

Kkill 84

Lless 50ln 57logname 14ls 34

Mman 21mkdir 32more 49mv 41

Nnewgrp 99nice 89

P

Index des commandesVersion : 0.6 178

passwd 17paste 160ps 83pwd 30

Rrenice 90rm 40rmdir 33

Ssort 161split 159

Ttail 52tar 105tee 94test 136time 85trap 155

tty 13

Uumask 100unalias 121uncompress 110uniq 163unix2dos 78until 143

Vvi 69

Wwc 53while 142who 16who am i 15

Zzcat 110

Index des commandesVersion : 0.6 179

mémo de vi

Sortie de VI

:q!<CR> sort sans sauvegarde

ZZ<CR> sort avec sauvegarde

:wq<CR> idem (date de modification toujours changée)

:x<CR> idem (sans modification de date si aucun changement)

:sh<CR> sort avec un shell fils

:!cde<CR> sort temporairement avec cde

Insertion de texte

a<txt><ESC> insère après le curseur

i<txt><ESC> insère avant le curseur

A<txt><ESC> insère à la fin de la ligne courante

I<txt><ESC> insère au début de la ligne courante

o<txt><ESC> insère une ligne après la ligne courante

O<txt><ESC> insère une ligne avant la ligne courante

Déplacement du curseur

Sur caractères

Flèches déplace le curseur d'un caractère

Sur lignes

^ déplace le curseur en début de ligne courante

$ déplace le curseur en fin de ligne courante

<CR> déplace le curseur en début de ligne suivante

déplace le curseur en fin de ligne précédente

mémo de viVersion : 0.6 180

Sur page courante

H déplace le curseur en tête de la page

M déplace le curseur au milieu de la page

L déplace le curseur à la fin de la page

Sur mots

w déplace le curseur au début du mot suivant

W idem avec l'espace comme séparateur imposé

b / B déplace le curseur au début du mot courant

e / E déplace le curseur à la fin du mot courant

Sur phrases

( déplace le curseur au début de la phrase courante

) déplace le curseur à la fin de la phrase courante

Sur paragraphes

{ déplace le curseur au début du paragraphe courant

} déplace le curseur à la fin du paragraphe courant

Sur chaînes de caractères

/chaîne<CR>déplace le curseur sur chaîne

?chaîne<CR> idem en remontant dans le fichier

//<CR> recherche chaîne suivante

??<CR> idem en remontant dans le fichier

n recherche dans le même sens

N recherche en inversant le sens

Sur autres pages

z.<CR> affiche la page centrée sur ligne courante

z<CR> affiche la page avec ligne courante en haut

z<CR> affiche la page avec ligne courante en bas

<CTL>D affiche la page une demipage en bas


<CTL>U affiche la page une demipage en haut

<CTL>F affiche la page une page en avant

<CTL>B affiche la page une page en arrière

:n<CR> affiche la page avec ligne n en haut

nG idem

:$ ou G affiche la dernière page

Destruction

De caractères

x détruit le caractère courant

3x détruit 3 caractères à partir du courant

X détruit le caractère précédent

De mots

dw détruit le mot courant à partir du curseur

3dw détruit 3 mots à partir du mot courant

De lignes

dd détruit la ligne courante

3dd détruit 3 lignes à partir de la ligne courante

De texte

d$ détruit la fin de ligne à partir du curseur

d/chaîne détruit jusqu'à chaîne non comprise

Remplacement

De caractères

rc remplace le caractère courant par "c"

R<txt><ESC> remplace 3 caractères par les lettres "txt"

s<txt><ESC> remplace le caractère courant par "txt"


De mots

cw<txt><ESC> remplace un mot par "txt"

De lignes

S<txt><ESC> remplace la ligne courante par "txt"

De texte

C ou c$ remplace la fin de ligne

c/chaîne remplace jusqu'à chaîne non comprise

Copie de texte

y3w met les 3 mots dans le tampon

Y ou yy idem pour la ligne courante

5yy idem sur 5 lignes

p copie du tampon après le curseur

P copie du tampon avant le curseur

Possibilité de préfixer ces commandes de "x , où x correspond au nom du tampon (une et une seule lettre).

Divers

u annule la dernière directive de modification

U restaure la ligne courante

. répète la dernière modification

:r fic2<CR> contenu de fic2 inséré dans tampon de vi

:r !cmd<CR> résultat de cmd inséré dans tampon de vi

:e fic2<CR> chargement de fic2 dans tampon courant

:e #<CR> retour au fichier initial

J concatène la ligne courante et la suivante

<CTRL>L rafraîchit l'écran

~ inverse majuscule < > minuscule (possibilité de faire précéder d'un nombre de caractères)

:set nu<CR> affiche la numérotation des lignes

:set nonu<CR> supprime la numérotation des lignes


mémo sur les tests

Sur fichiers

r/w/x fic vrai si fic existe et a le droit r, w ou x

f/d fic vrai si fic existe et est ordinaire ou répertoire

b/c fic vrai si fic existe et est en mode bloc ou caractère

s fic vrai si fic existe et n'est pas vide

fic1 ef fic2 vrai si fic1 et fic2 sont liés

L fic1 vrai si fic1 est un lien symbolique

fic1 ot fic2 vrai si date de modif de fic1 plus vieille

fic1 nt fic2 vrai si date de modif de fic1 plus récente

Sur numériques

eq / ne / gt / ge / lt / le

== / != / > / >= / < / <=

Sur chaînes de caractères

ch1 = ch2 vrai si chaîne1 égal à chaîne2

ch1 != ch2 vrai si chaîne1 différente de chaîne2

z chaîne vrai si chaîne existe et est vide

n chaîne vrai si chaîne existe et n'est pas vide

mémo sur les testsVersion : 0.6 184

unix linux utilisation des systèmes - anakal.free.franakal.free.fr/ebooks d'informatique -...

Documents