Rapport de projet shell

Faculté Des Sciences et Techniques de Tanger - Département Génie Informatique

Cycle ingénieur Logiciel et Système Informatique

Projet de Fin de Module
PROGRAMMATION SYSTEME

LSI-SHELL
Réalisé par : Proposé par :

ASSAOUY Samia.

LASRI Ayyoub. Dr. El AMRANI Chaker.

ZIANE Bilal.



Sommaire

INTRODUCTION ............................................................................................................................................. 4

CONTEXTE DU PROJET .................................................................................................................................. 5

Analyse du besoin : ................................................................................................................................... 5
L’Object du projet : ................................................................................................................................... 5
Technologies et langage :.......................................................................................................................... 5

CARACTERISTIQUES GENERALE DU SYSTEME UNIX ...................................................................................... 6

Evolution : ................................................................................................................................................. 6
Philosophie :.............................................................................................................................................. 7
Caractéristiques : ...................................................................................................................................... 7
Le Noyau : ................................................................................................................................................. 8
Le SHELL : .................................................................................................................................................. 9
Différentes SHELL : .................................................................................................................................... 9

UTILISATION DU SHELL................................................................................................................................ 10

Introduction : .......................................................................................................................................... 10
- SHELL ? ........................................................................................................................................ 10
- Utilisateurs ? ............................................................................................................................... 11
Fonctionnement du SHELL: ..................................................................................................................... 12
Mécanisme d’interprétation du SHELL : ................................................................................................. 12
- Définition : .................................................................................................................................. 12
- PROMPT : .................................................................................................................................... 12



- Rechercher la commande : ......................................................................................................... 13
- Exécution d’une Commande : ..................................................................................................... 13
- Redirection : ................................................................................................................................ 14
- Lancement en arrière plan : ........................................................................................................ 14

CONCEPTION ET ANALYSE........................................................................................................................... 15

Analyse fonctionnelle :............................................................................................................................ 15
- Spécifications : ................................................................................................................................ 15
- Acteurs : ...................................................................................................................................... 15
Analyse Organique : ................................................................................................................................ 15
- Spécification des Classes : ........................................................................................................... 15

MISE EN ŒUVRE ET IMPLEMENTATION ..................................................................................................... 16

Technologies utilisés : ............................................................................................................................. 16
Détails sur les fonctions prédéfinis utilisés : ........................................................................................... 16
Détails sur les fonctions implémentés : .................................................................................................. 18

CONCLUSION............................................................................................................................................... 20
Captures d’écran: ........................................................................................................................................ 22



INTRODUCTION

Interpréteur de commandes des Systèmes GNU/LINUX SHELL est devenu pour
les administrateurs système, un outil incontournable.
Ce rapport présente une description du projet de fin de module programmation
système un SHEL personnalisé.
Dans ce cadre, nous tenons à donner une présentation de l’environnement
GNU/LINUX, ses caractéristiques et son noyau en expliquant la communication
entre l’utilisateur et le système (gérée par le noyau) via l’interpréteur des
commandes le SHELL.



CONTEXTE DU PROJET

Analyse du besoin :

Notre premier travail a consisté à bien analyser le sujet avant de se lancer dans
l’implémentation.

Nous avons, dans un premier temps, commencé par étudier le SHELL GNU/Linux
pour récolter le maximum d’informations possibles.

L’Object du projet :

L’objet de notre projet c’est la réalisation d’un SHELL personnalisé, qui offre les
fonctionnalités suivantes :

 Attendre jusqu’à ce que l’utilisateur fournis une commande valide.
 Interprétation des commandes.
 Communication entre les différentes commandes via les tubes de
communication.
 Redirection des entrées et des sortie de l’exécution de la commande.

Technologies et langage :

Système d’exploitation : UBUNTU.

Langage de programmation : Langage C.



CARACTERISTIQUES GENERALE DU SYSTEME UNIX

Evolution :

Le système d’exploitation UNIX a commencé en 1969 aux laboratoires de
recherche en informatique d’AT&T pour répondre aux besoins des ingénieurs de la
société que ken Thompson a écrit le système Unix, un système interactif qui met
l’accent sur les utilitaires de développement logiciels, partage de fichiers.

Le nom UNIX est attribué par opposition au système Multics. La première
évolution interne marquante d’Unix a été sa réécriture ,par Ken Thompson et
Denis Ritchie en langage C, lequel a été inventé pour la cause en 1971. En
1975, le système Unix est distribué aux universités et aux centres de
recherches.

La principale université qui va travailler sur Unix est l’université de Berkeley, qui
va produire ses propres versions appelées BSD pour Berkeley Software
Distribution.

En 1979, les Bell Labs sortent leur version, la première à être diffusée dans le
monde industriel.

On peut dire qu’elle est à l’origine du développement du marché Unix.

Unix. Plusieurs facteurs vont alors jouer pour canaliser et recentrer l’offre Unix: la
complexité croissante des systèmes et l’action des utilisateurs.

(Sun Microsystems, Digital...) et lui permettre d’entrer dans le monde industriel.

Le début des années 90 est marqué par le regroupement des constructeurs au
sein de deux organisations: l’U.I. (Unix International) créée à partir de
l’accord entre A.T.&T. et Sun Microsystems d’une part et l’O.S.F. D’autre



part. Le premier accord a comme objectif la convergence entre les différentes
versions.

Philosophie :

Conçus à l’origine comme un environnement de développement, Unix est
aujourd’hui un système complet intégrant un grand nombre de fonctionnalités
organisées en couches logicielles. en dehors de cette structure modulaire,
Unix se caractérise également par les concepts introduits en matière de gestion
de fichiers et de gestion des processus.

Caractéristiques :

Unix est le système d'exploitation des grands serveurs par excellence.

Multitâche, multiutilisateur, multiplateforme, réparti et sécurisé.

Ecrit en langage C, permettant ainsi une portabilité sur la plupart des architectures.

Sa popularité est, en fait, due à sa conception modulaire avec des interfaces
bien définies ainsi que la disponibilité d’outils simples qui coexistent entres elles.
Alors que les autres systèmes d’exploitation ressemblent à des ensembles
monoblocs et relativement fermés, la conception du système repose sur
différents niveaux bien distincts: le noyau, un interpréteur de commandes (le
SHELL), des bibliothèques et un nombre important d’utilitaires.

Le système Linux possède notamment les avantages suivants :
 Le support des standards de l'internet, c'est-à-dire des protocoles TCP/IP, la
famille de protocoles utilisée sur Internet. Il est donc un moyen gratuit de créer
un réseau local, de se connecter à Internet et de mettre en place un serveur.
 Une sécurité accrue dû à la transparence de son code source et de la réactivité de
la communauté lors des annonces de vulnérabilités.



 Un cloisonnement des espaces mémoire et de l'espace disque couplé à une
gestion pointue des droits permettant de gérer un grand nombre d'utilisateurs
avec un niveau de risque minimal.
 Un noyau entièrement configurable en fonction du matériel de la machine sur
laquelle le système est installé afin de maximiser les performances.

Le Noyau :

Linux est architecturé autour d'un noyau (KERNEL) chargé de prendre en charge
le matériel. On appelle distribution l'assemblage d'un ensemble de logiciels autour
d'un noyau Linux afin de fournir un système clé en main. Le noyau d'une
distribution peut-être mis à jour afin de permettre la prise en compte de matériels
récents, toutefois cette manipulation consistant à recompiler le noyau est délicate
car elle nécessite un certain niveau de connaissance du système et du matériel. La
recompilation du noyau est à réserver aux spécialistes ou bien aux utilisateurs prêts
à rendre inutilisable leur système dans le but d'apprendre.

La plupart des distributions proposent également une installation graphique qui
leur est propre ainsi qu'un système de gestion de paquetages permettant d'installer
automatiquement des logiciels en gérant les dépendances (les logiciels sous Linux
sont parfois liés à des librairies externes ou s'appuient sur d'autres logiciels).



Chaque distribution possède ses avantages et ses inconvénients. En effet si
certaines sont plus adaptées à des débutants et proposent des interfaces graphiques
évoluées, d'autres privilégient la sécurité ou l'évolutivité. Les distributions les plus
connues sont :
 La distribution RedHat ;
 La distribution Debian ;
 La distribution SuSe ;
 La distribution Knoppix ;
 La distribution Slackware ;
 La distribution Mandriva.

Le SHELL :

Le SHELL, comme le normalien, ne connaît que deux états :

 le travail ;
 l'inactivité.

Le SHELL, une fois lancé, est inactif : il attend qu'on lui donne des ordres.
Quand on lui en donne un, il l'exécute ; et quand il a terminé, il retourne à son état
d'inactivité, en attente d'un nouveau commandement.

Différentes SHELL :

Il y a deux familles de SHELL :

 le Bourne-SHELL (sh) :
o z-SHELL (zsh).
o Bash.
o ksh.
o le c-SHELL (csh) : tcsh.



UTILISATION DU SHELL

Introduction :

- SHELL ?

On parle souvent de Linux en disant que c’est le paradis des fanas de la « ligne de
commandes ». En effet, sous Linux, ou dans tout système Unix, il est tout à fait
possible de gérer le système uniquement avec des commandes écrites par
l’utilisateur ou par un programme, script …

Le SHELL est donc l’interface entre la commande et le noyau linux. C’est en fait
la couche la plus externe du système, celle qui entoure le noyau d’où son nom de
« SHELL » ou « Coquille ». Ainsi, lorsque l’utilisateur tape une commande dans
une console, le SHELL l’interprète et le transmet au noyau Linux. Pour interagir
avec le noyau, il vous faut donc le SHELL et un terminal, une console virtuelle ou
une autre interface graphique.

Pour expliquer ceci autrement, le SHELL est un exécutable capable d’interpréter
les commandes, de les transmettre au noyau et de retourner la réponse. Voici un
schéma qui illustre la place du SHELL dans le système:

On voit que le SHELL est bien à l’interface entre le noyau Linux et l’utilisateur par
le biais d’une console, d’une application ou entre le noyau et une application, un
script.



- Utilisateurs ?

En résumé, à un utilisateur correspond les renseignements suivants:

• un nom de login,

• un mot de passe,

• un iud,

• un ou plusieurs groupes de travail,

• un répertoire HOME,

• un SHELL par défaut.

 L’utilisateur de base:

Il utilise les applicatifs mis à sa disposition, il «customise» les applications, il
possède des droits d’accès traditionnels, il doit veiller à utiliser les ressources
(disques, CPU,...) avec modération afin de ne pas surcharger le système.

 Le programmeur:

Il possède les mêmes droits que l’utilisateur de base, il a en plus la possibilité de
programmer ses propres applications, il utilise donc dans ce cas, les outils de
développement installés sur le système, il a accès aux compilateurs et à
l’interpréteur.

 L’administrateur système:

Il possède les mêmes droits que le programmeur. Son rôle est plus grand: il gère le
système, il possède des droits d’accès étendus (il peut descendre dans toutes
les arborescences de son système), il crée des comptes pour tous les
utilisateurs de son serveur, il veille au bon fonctionnement général du
système, il installe les outils nécessaires à la communauté, il surveille et
régularise la charge du système et des ressources de la machine.



Fonctionnement du SHELL:

New Line correspond au retour à la ligne (généralement la touche Entrée).

Mécanisme d’interprétation du SHELL :
- Définition :

Le SHELL est l’interpréteur de commandes, il n’est pas inclus dans le noyau
d’Unix. Quand un utilisateur rentre dans le système, le SHELL par défaut qui lui a
été donné, est automatiquement lancé et toute la session se déroule en fait
dans ce SHELL. Lorsque cet utilisateur tape une commande, le SHELL la lit,
l’interprète et lance son exécution. La ligne tapée peut ne comporter qu’une seule
commande mais peut aussi être complexe.

- PROMPT :

Le SHELL indique qu’il est prêt à recevoir une nouvelle commande en affichant le
prompt (par défaut «$»). Toute commande se termine par un passage à la
ligne, dans certains cas, le passage à la ligne à une signification particulière
pour la commande tapée et n’est donc pas considéré comme un terminateur de
commande. Dans ce cas, le SHELL affiche le deuxième prompt (par défaut
«>») pour indiquer qu’il attend la suite de la commande.

Il est aussi possible de taper plusieurs commandes sur la même ligne en les
séparant par un «;».



- Rechercher la commande :

Si la commande tapée correspond à une commande interne du SHELL, cette
commande est exécutée à l’intérieur de ce SHELL. Sinon, si la commande
correspond à une fonction (cf. partie sur le langage de programmation) elle est elle
aussi exécutée à l’intérieur du SHELL.

Dans tous les autres cas, la commande se réfère à un fichier de l’arborescence. Si le
nom ne comporte pas de caractère «/», le SHELL examine la variable PATH pour
rechercher le répertoire où ce trouve cette commande. Un nouveau SHELL est
alors créé pour exécuter cette commande.

Si la commande est un script SHELL, le SHELL lit toutes les lignes du script et les
exécutent. Si la commande appelle un fichier binaire exécutable, le code et les
données associées du processus du deuxième SHELL sont remplacés par le code et
les données associés à la commande.

- Exécution d’une Commande :

La première chose c’est de lire la commande, l’analyser si elle est valide, et ensuite
l’exécuter

Pour exécuter une commande son nom suffit généralement. Cela veut
dire dans ce cas que c’est une commande interne ou qu’elle est localisable
dans le chemin d’exécution de l’utilisateur (PATH).

Dans le cas contraire, il faut :

 donner le chemin absolu de la commande
 ou se trouver dans le répertoire où se trouve la commande



- Redirection :

Avant de lancer un processus, le SHELL lui attribue trois fichiers:

• Une entrée standard (par défaut le clavier),

• Une sortie standard (par défaut l’écran),

• Une sortie d’erreur standard (par défaut l’écran).

Ces trois directions peuvent être liées à d’autres fichiers que ceux indiqués ci-
dessus grâce aux commandes de redirection. Le SHELL associera donc d’autres
fichiers que le clavier ou l’écran et il lancera ensuite la commande.

- Lancement en arrière plan :

Lorsqu’on lance une commande, le SHELL attend la fin de l’exécution de cette
dernière avant de redonner la main à l’utilisateur.

Si on ajoute un «&» à la fin de la ligne de commande, le SHELL
n’attends plus la fin de l’exécution de cette commande, il la lance en arrière
plan.

Quand on lance une commande en arrière plan dans un SHELL interactif (c’est à
dire pas dans un Script SHELL), le SHELL renvoie à l’écran le numéro du job
pour le SHELL qui a lancé la commande ainsi que le numéro du processus dans la
table des processus.

Le caractère «&» est un terminateur de commande, il est donc possible de
taper une commande à la suite sans passage à la ligne.



CONCEPTION ET ANALYSE

Analyse fonctionnelle :
- Spécifications :
 Le SHELL demande la commande en invite de commande ( PROMPT ).
 Le SHELL interprète un ou plusieurs commandes.
 La commande a un ou plusieurs arguments.
 La sortie de l’exécution d’une commande peut être redirigée vers un fichier.
 Communication entre commandes par les pipes.

- Acteurs :
Utilisateur du SHELL peut exécuter un ou plusieurs commandes.

Analyse Organique :
- Spécification des Classes :
Une seule classe suffit pour la mise en œuvre, c’est la classe commande.



MISE EN ŒUVRE ET IMPLEMENTATION
Technologies utilisés :

Langage C : un langage interactif, portable, inventé avec UNIX par DENNIS
RITCHIE.

Détails sur les fonctions prédéfinis utilisés :

#include <string.h>

char *strchr (const char *s, int c);
char *strrchr (const char *s, int c);

La fonction strchr() renvoie un pointeur sur la première occurrence du
caractère c dans la chaîne s.

#include <string.h>
char *strtok (char *s, const char *delim);

Un élément lexical (token) est une chaîne non vide de caractères qui
n'appartiennent pas à la chaîne delim, suivie de 0 ou d'un caractère appartenant
à delim.

#include <sys/types.h>
#include <sys/stat.h>
struct stat {
dev_t st_dev, /* identification du disque logique */
ino_t st_ino; /* i-nombre du fichier sur ce disque */



mode_t st_mode, /* type et droits d’accès */
nlink_t st_nlink; /* nombre de liens physiques (Hard) */
uid_t st_uid; /* propriétaire du fichier */
gid_t st_gid; /* groupe propriétaire du fichier */
off_t st_size; /* tai11e du fichier */
time_t st_atime; /* date de dernier accès */
time_t st_mtime ; /* date de dernière modification */
time_t st_ctime; /* date de dern. modif. du i–noeud */
}
Contient la définition de la structure stat qui est utilisée pour obtenir les
informations contenues dans le nœud d’un fichier.

char * getenv ( const char * name );

Retourne la valeur des variables d’environnements.

free( <Pointeur> );
libère le bloc de mémoire désigné par le <Pointeur>; n'a pas d'effet si le pointeur a
la valeur zéro.

char *fgets( char *str, int nb, FILE *flux) ;
La fonction fgets() lit jusqu'à nb-1 caractères depuis le fichier flux et stocke le
résultat dans str. La chaîne de caractère produite par fgets() est toujours terminée
par NULL.

#include <assert.h>

void assert( int exp );

assert(expression). Si expression est fausse (ou égale à 0), alors un message
d'erreur est affiché et le programme est arrêté par abort



Détails sur les fonctions implémentés :

Fonction = void afficherPrompt()

Description :

Affiche une prompt pour l’utilisateur : UTILISATEUR @
CHEMAIN

Fonction = void lireLaCommande(char* buffer)

Description :

Lit l’entrée standard, vide l’entrée si on dépasse la taille du
buffer.Termine à ‘n’.

Fonction = void remplirLaStructure(char* commandLine, struct
command_t* parsed_command)

Description :

Prends la ligne de commande séparée par espace.

Argc Le nombre des arguments.

Argv Les arguments séparés par espace.

Fonction = char* commandesPerso(char* cmd,int i)

Description :

Définition de nos commandes personnalisées.

Fonction = void passerLePath(char* dirs[])

Description :



Affiche les dossiers séparés par le délimiteur ‘ :’

Fonction = char* chercherLaCommandeDansLesPaths(char* argv[], char*
dir[])

Description :

Rechercher la commande si existe ou pas, et Vérifie si le fichier ordinaide a
les droit d’exécution.

Fonction = void lesRedirections(struct command_t* command, struct IO*
fid)

Description :

Fonction de gestion et détection des redirections.

Fonction = void executerLesCommandes(struct command_t* command, struct
command_t* command2, int pipe_proc)

Description :

Détermine la manière d’exécution des processus, et gère les pipes si
nécessaire.



CONCLUSION

Notre projet nous a permit de renforcer tout les connaissances que nous avons
acquis dans la programmation système, et nous a donné une occasion bénéfique sur
différents plans technique et technologique.

Cette initiative n’est qu’un début pour plusieurs autres projets beaucoup plus
étendues. Nous espérons que nous étions à la hauteur et que notre effort sera
apprécié.



ANNEXES



Captures d’écran:

Rapport de projet shell

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Rapport de projet shell

Similaire à Rapport de projet shell (20)

Plus de Bilal ZIANE

Plus de Bilal ZIANE (7)

Dernier

Dernier (20)

Rapport de projet shell