Programmation système et réseau sous unix

Programmation système et réseau sous unix
Bruno GAS
!
Orientation IRSI - 2014/2015
Organisation de l’UE
Encadrement:
• Responsable UE: Bruno Gas ([email protected])
• Chargée(e) de TP et projets: Soukeyna Bouchebout
([email protected])
!
Séances (30h):
• 3 cours - 6h
• 3 TPs - 12h (3 groupes)
• 3 Projets - 8h (3 groupes)
Organisation de l’UE
Evaluation (3 ECTS):
• Note d’écrit: Contrôle de TP sur machine (écrit ou oral au rattrapage)
Documents écrits et programmes réalisé en TP autorisés
Pas de machines personnelles, pas d’accès à Internet
• Note de TP: évaluation du projet (non rattrapable)
Rapport du projet, codes sources, exécutable
Projets en monômes. !
Documentation - énoncés de TP/projets:
• Site Internet de la spécialité: http://www.edu/upmc/sdi/isi • Login/Passwd: M1IRSI2014 / esclan14
Organisation de l’UE
Emploi du temps
•
•
•
•
•
•
•
•
•
•
•
•
•
Cours
COURS 1/4: Mercredi 1er octobre, 10h45-12h45
COURS 2/4: Mercredi 8 octobre, 10h45-12h45
TP 1/3, gr C1+C2: Mercredi 15 octobre, 8h30-12h45
COURS 3/4: Mercredi 22 octobre, 10h45-12h45
TP 1/3, gr C3+C4: Mercredi 29 octobre, 8h30-12h45
TP 2/3, gr C3+C4: Jeudi 13 novembre, 8h30-12h45
TP 2/3, gr C1+C2: Jeudi 20 novembre, 8h30-12h45
TP 3/3, gr C3+C4: Mercredi 26 novembre, 8h30-12h45
TP 3/3, gr C1+C2: Jeudi 27 novembre, 8h30-12h45
PROJET 1/2, gr C1+C2: Mercredi 3 décembre, 8h30-12h45
PROJET 1/2, gr C3+C4: Jeudi 4 décembre, 8h30-12h45
PROJET 2/2, gr C1+C2: Mercredi 10 décembre, 8h30-12h45
PROJET 2/2, gr C3+C4: Jeudi 11 décembre, 8h30-12h45
!
•
•
•
Examens
Examen de TP (note d'écrit), Gr C1+C2: Jeudi 18 décembre, 13h45-15h45
Examen de TP (note d'écrit), Gr C3+C4: Jeudi 18 décembre, 15h45-17h45
Remise des projets (note de TP), Date à définir (Vendredi 19 décembre)
Plan du cours
• Unix - utilisation / fichiers
• Création et synchronisation de processus
• Communication par signaux et tubes
• Programmation réseau
Introduction
• Unix est un système d’exploitation
• Né aux laboratoires Bell (AT&T) en 1970 (Ken Thompson, Dennis Ritchie,
Brian Kernighan)
• Ecrit en langage C en 1973
• Système multi-tâches et multi-utilisateur
Source: http://www.commentcamarche.net/
Source: wikipedia
Vue générale du système
Un système
d’exploitation
est un
programme qui
sert d’interface
entre un
utilisateur et un
ordinateur
C’est aussi un
ensemble de
procédures qui
permet à un
groupe
d’utilisateurs de
partager
efficacement un
ordinateur
Point de vue utilisateur
Structure en couches et
«Encapsulation»
Chaque couche est conçue
pour pouvoir être utilisée
sans connaître les couches inférieures
Architecture du noyau
Structure en
éléments
disjoints et
programmables
de façon
disjointe
Pourquoi unix ?
• Le prix
• Disponibilité des sources
• Intelligence des solutions mises en oeuvre
• Système simple et ouvert • Grande ressource bibliographique
Raisons du succès d’unix/linux
• Ecrit dans un langage de haut niveau (C)
• Une interface simple et puissante (les «shells»)
• Des primitives puissantes qui simplifient l’écriture des programmes
• Multi-utilisateurs et multitâches
• Format générique pour les fichiers (flot d’octets)
• Architecture de la machine cachée à l’utilisateur
• ...
Points faibles
• Fragilité du SGF (corrigée avec les SGF journalisés)
• Gestion et rattrapage des interruptions inadaptés au temps réel
• Mécanisme de création/gestion des processus lourd (amélioré avec la gestion
des threads)
Le système de gestion de fichiers
C’est un outil de manipulation des fichiers
• Pour le système
• Pour les utilisateurs
Stockage des objets importants du système
• mémoire
• terminaux,
• périphériques variés
•...
Stockage des données des utilisateurs
• Partage: utilisation d’un même fichier par plusieurs utilisateurs
• Efficacité: utilisation de cache, uniformisation des accès
• Protection des éléments important du système
• Protection inter-utilisateurs
Concept de fichier
L’unité logique de base est : le fichier
Suite finie de bytes matérialisée par des blocs disques et une inode
Contient les propriétés du fichier, mais pas son nom:
• Localisation sur le disque
• Propriétaire et groupe propriétaire
• Droits d’accès
• Taille
• Date de création
Un nom est lié à un fichier mais un fichier n’est pas lié à un nom. Un
fichier peut exister sans avoir de nom dans l’arborescence
Arborescence
• Une seule racine
• Une structure dynamique
• Une grande puissance d’expression
• Un graphe acyclique
Arborescence sous linux
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
/
/bin
/boot
/dev
/etc
/etc/rc.d
/etc/X11
/etc/sysconfig
/etc/cron
/home
/lib
/mnt
/opt
/root
/sbin
/tmp
/usr
/var
/proc
Racine
Les fichiers exécutables (en binaire)
Le noyau et les fichiers de démarrage
Fichiers spéciaux de communication avec les périphériques
Fichiers de configuration du système
scripts de démarrage du système
scripts de configuration du serveur X
configuration des périphériques
description des tâches périodiques à effectuer
Racine des répertoires personnels des utilisateurs
Bibliothèques et modules du noyau
Racine des points de montage des systèmes de fichier périphériques
Applications supplémentaires
Répertoire personnel de l’utilisateur root
Fichiers exécutables pour l’administration du système
Stockage des fichiers temporaires
Programmes accessibles à tout utilisateur (structure id. à la racine)
Données variables liées à la machine (ex: fichiers d’impression)
Pseudo répertoire contenant une «image» du système
Types de Fichiers
• Fichiers répertoires : catalogue de noms de fichiers
• Fichiers standards : les fichiers textes, les programmes, tout ce qui est
manipulé par l’utilisateur
• Liens symboliques : pointeur sur un autre fichier
• Fichiers spéciaux : fichier associé à un périphérique. Lorsqu’on agit sur ce
fichier, on agit en fait sur le périphérique
• Exemple: le répertoire /dev : Il contient les dispositifs matériels
(périphériques, devices)
Périphériques pour lesquels
la communication se fait octets par octets
Character devices:
• Terminaux
• Imprimantes
• Mémoirte, ...
Périphériques pour lesquels
la communication se fait par blocs d’octets
Block devices:
• Disques
• Bandes magnétiques
• Lecteurs/graveurs DVD, ...
Création / édition d’un fichier
• Créer un fichier : touch nom_fic <CR>
• Afficher le contenu d’un fichier :
• cat nom_fic <CR>
Mode déplacement
• more nom_fic <CR>
D
• Editer un fichier : vi nom_fic <CR>
<:>
<Escape>
<i>
<wq>
<q!>
C
Mode commande
I
Mode insertion
Droits d’accès aux fichiers et répertoires
• Pour chaque fichier, 3 classes d’utilisateurs :
!
u
user
g
group
o
others
• Pour chaque classe d’utilisateur, 3 types d’accès :
!
• Exemples :
r
read
w
write
x
-
execute none
Modifier les droits
• Pour modifier les droits, il faut être propriétaire du fichier:
• chmod <mode> <fichier> <CR>
opérateurs :
+ : ajoute un droit
- : retire un droit
= : droit absolu
• Exemples :
chmod
chmod
chmod
chmod
u+rw toto.txt
o-rwx toto.txt
a+r toto.txt
go=r toto.txt
opérandes:
u : droits du propriétaire
g : droits du groupe du propriétaire
o : droits des autres utilisateurs
a : droits de tous les utilisateurs
Redirections
• Une commande unix :
• lit ses données sur le fichier d’entrée standard (le clavier)
• écrit ses résultats sur le fichier standard de sortie (l’écran)
• écrit ses erreurs sur le fichier standard d’erreur (l’écran)
• A chaque fichier standard correspond un descripteur (ou numéro) :
!
0 : stdinput
1 : stdoutput
2 : stderror
• Les entrées/sorties standard peuvent être redirigées :
cat toto.txt > fichier.txt
ls >> fichier.txt
ls 2> messages.txt
mail [email protected] < fichier.txt
Tubes (Pipes)
• Système d’échange d’informations entre deux commandes exécutées en
parallèle • Exemple : • cat toto.txt | more <CR>
cat
!
more
fichier «toto.txt»
!
• ls | grep ‘toto’ <CR>
Affichage page par page
Lignes du fichier
Commande grep
• Recherche les occurrences d’une chaîne de caractères
• grep [option] <critere> [fichier (s)] <CR>
• Exemple :
• ls > ls.txt <CR>
• grep ‘toto’ ls.txt <CR>
<critere> :
[...] un intervalle de caractères
[^...] complément de l’intervalle indiqué
.
n’importe quel caractère
*
répétition du caractère précédent
^
en début de ligne pour la recherche
$
en fin de ligne pour la recherche
• ls | grep ‘toto’ <CR> • grep ‘^#’ toto.txt <CR>
Rechercher toutes les lignes qui commencent par #
Fichiers: Appels systèmes de base
• Unix fournit deux ensembles de fonctions d’entrées/sorties
• Les appels système
Primitives réalisées directement par le noyau
• Manipulation directe des fichiers
• Entrées/sorties de données non typées
•
!
!
• La bibliothèque d’entrées/sorties standard (printf, scanf, fprintf,
fscanf...)
Entrées/sorties «haut niveau»
• Conversions de données
•
Exemple: CopieFichier.c
// CopieFichier.c!
// Ecriture d’un fichier dans un autre!
// usage : copie fichier_source fichier_destination!
!
!
#include
#include
#include
#include
#include
#include
!
<sys/types.h>
<sys/stat.h>
<sys/fcntl.h>
<sys/unistd.h>
<sys/errno.h>
<sys/stdio.h>
//
//
//
//
//
//
définitions de types (ex: size_t)!
informations sur les fichiers!
ctrl des descripteurs de fichiers !
fonctions e/s bas niveau!
gestion des erreurs!
fonctions e/s haut niveau!
void main (int arc, char *argv[]) {!
int fd1, fd2, buffer[1024];!
ssize_t n;!
!
if (argc != 3) {!
printf (‟usage:%s source cible\n‟, argv[0]);!
exit(1);!
}!
!
...
Exemple: CopieFichier.c (suite)
fd1 = open(argv[1], O_RDONLY);!
if (fd1 == -1) {!
perror(‟open1‟);!
exit(1);!
}!
!
fd2 = open(argv[2], O_WRDONLY | O_TRUNC | O_CREAT);!
if (fd2 == -1) {!
perror(‟open2‟);!
exit(1);!
}!
!
do {!
n : read(fd1, (void *) buffer, sizeof(buffer));!
if (n>0)!
if (write(fd2, (void*) buffer, n) != n)!
perror (‟write‟);!
}while (n>0)!
!
close (fd1);!
close (fd2);!
exit(0);!
} !
Descripteurs de fichiers
• Les descripteurs sont de simples entiers alloués lors de l’ouverture d’un
fichier et désalloués lors de sa fermeture.
• Pour le noyau, ils représentent des entrées dans une table de descripteurs
contenant les informations de contrôle. • Trois descripteurs ont une signification particulière :
• Le descripteur 0 : entrée standard
• Le descripteur 1 : sortie standard
• Le descripteur 2 : sortie d’erreur
• Exemple : char buffer[1024];!
write(0, (void*)buffer, 1024);
?
printf(buffer);
Le buffer cache
• Lors d’une écriture dans un fichier, les données sont d’abord écrites dans des
tampons mémoire, via le buffer cache, puis sauvegardées régulièrement sur
le disque par le processus update.
programme
!
e/s
Disque
!
update
!
Buffer cache
!
autre programme
option O_SYNC
fonction int sync (void)
• Les processus ne sont pas stoppés pendant l’écriture (gestion asynchrone)
• Accès concurrent optimisé