Vous êtes sur la page 1sur 62

Outils de communication entre processus

Les signaux

Méthodes de Programmation Système 2008/2009 J. Delacroix 1


Signaux : définition

• Le signal est une interruption logicielle délivrée à un processus.


– Il informe les processus de l'occurrence d'événements
asynchrones et permet de faire exécuter à un processus une
action relative à ces événements.
– Il ne transporte pas de données.

• 64 signaux identifiés par un numéro et un nom (SIGX)


– 1 à 31 : signaux classiques
– 32 à 63 : signaux temps réel

Méthodes de Programmation Système 2008/2009 J. Delacroix 2


Signaux Classiques

• L'événement associé à un signal


– extérieur au processus (frappe caractère, terminaison d'un
autre processus)
– intérieur au processus correspondant à une erreur (erreur
arithmétique ou violation mémoire) : levée d'une trappe.

Méthodes de Programmation Système 2008/2009 J. Delacroix 3


Liste des signaux selon le standard POSIX

• signaux relatifs à la fin de processus :


– SIGCHLD (17) : mort du fils
– SIGKILL (9) : signal de terminaison

• signaux relatifs à des erreurs (trappes)


– SIGILL (4) : instruction illégale
– SIGFPE (8) : erreur arithmétique
– SIGSEGV (11) : violation mémoire
– SIGPIPE (13) : écriture dans un tube sans lecteur

• signaux relatifs aux temporisations


– SIGALRM (14): fin de temporisation (fonction alarm)

• signaux relatifs aux interactions avec le terminal (extinction, frappe touche DELETE et
BREAK)
– SIGHUP, SIGINT (crtl C), SIGQUIT (crtl \)

• signaux relatifs à la mise au point de programmes

• Deux signaux disponibles pour les utilisateurs (SIGUSR1, SIGUSR2)

Méthodes de Programmation Système 2008/2009 J. Delacroix 4


Signaux : aspects du traitement

• Comment un processus reçoit-t-il un signal ?

• Quand un processus traite-t-il un signal reçu ?

• Comment un processus associe-t-il un traitement aux signaux ?

Méthodes de Programmation Système 2008/2009 J. Delacroix 5


Signaux : structures de données du processus
PCB
Typedef struct { unsigned long sig[2]; } sigset_t;
Signaux classiques 11100000001111111111111111111000
Signaux temps réel 01010011010010101001010101000101
files_struct
mm_struct Struct signal_struct { ……
struct k_sigaction action [64];
signal_struct …….}

volatile long state; - - état du processus TASK_STRUCT

sigset_t signal; -- signaux reçus


sigset_t blocked; -- signaux bloqués (« masqués »)

struct task_struct *next_task, *prev_task; -- chainage PCB


struct task_struct *next_run, *prev_run; -- chainage PCB Prêt
int pid; -- pid du processus
struct task_struct *p_opptr, *p_pptr, *p_cptr,; -- pointeurs PCB père originel, père
actuel, fils
long need_resched; -- ordonnancement requis ou pas
long utime, stime, cutime, cstime;
-- temps en mode user, noyau, temps des fils en mode user, noyau
unsigned long policy; -- politique ordonnancement SCHED_RR, SCHED-FIFO,
SCHED_OTHER
struct thread_struct tss; -- valeurs des registres du processeur
struct mm_struct *mm; -- contexte mémoire
struct files_struct *files ; -- table fichiers ouverts
struct signal_struct *sig ; -- table de gestion des signaux ; actions à réaliser
lors de la prise en compte des signaux par le processus
Méthodes de Programmation Système 2008/2009 J. Delacroix 6
1. Comment un processus reçoit-t-il un signal ?

• Un processus pid_A envoie un signal S à un processus pid_B par le biais


de la primitive kill.

 kill (pid_B, S)

 Positionnement d'un bit à 1 dans le champ signal de la table du


processus pid _B, correspondant au numéro de signal reçu.

 signal pendant (reçu)

 vecteur de bits : pas de mémorisation du nombre de signaux d'un type


reçu.

Signal[0]
Entier de 32 bits
00001100000000000000100000100010
Signaux 1, 5, 11, 27, 26 reçus

Méthodes de Programmation Système 2008/2009 J. Delacroix 7


2. Quand un processus traite-t-il un signal reçu ?

• Un processus traite les signaux reçus quand il quitte le mode noyau pour
retourner au mode utilisateur
 signal délivré, le bit correspondant est remis à 0; le traitement associé est
exécuté.

Utilisateur Noyau

Processus pid_A Processus pid_B Processus pid_A Processus pid_B

kill (pid_B, 4);


i = i = 1; Exécution de l’appel système
Fp = open (fichier); Open 00000…..10000
Need_resched = true;

Réordonnancement
Processus B élu Examen des signaux reçus
par le processus élu
Traitement
(do_signal())
Méthodes de Programmation Système 2008/2009 J. Delacroix 8
3. Comment un processus associe-t-il un traitement aux signaux ?

• Traitement des signaux

– A tout signal est associé un traitement par défaut (ignorer, terminer


le processus avec ou sans core, stopper le processus);

– Tout processus peut installer pour chaque type de signal (hormis


SIGKILL), un nouveau traitement appelé handler
• handler SIG_IGN : pour ignorer le signal (sauf mort du fils
pour Linux)
• handler fonction utilisateur pour capter le signal
 fonction signal et sigaction

Méthodes de Programmation Système 2008/2009 J. Delacroix 9


3. Comment un processus contrôle-t-il ses réactions
vis-à-vis des signaux ?
(fonction du noyau do_signal())
• Traitement des signaux

3 2 1 0
entier signal[0] 0 0 0 0 0 0 0
..........................
1 1 1 1 1 1 1

Indicateurs
de ..........................
Comportement
(sig)
SIG_IGN
rien SIG_DFL @handler
action définie par l’utilisateur
Méthodes de Programmation Système 2008/2009 J. Delacroix 10
Fonction do_signal()

signr = dequeue_signal()

Oui, tous les signaux pendants sont traités


signr = 0 ?

non
Récupération de l’action associée à signr, stockée dans ka
ka = &current->sig->action[signr-1]

Traitement défini par l’utilisateur


Ignorer le signal

Traitement par défaut


if (ka->sa.sa_handler == SIG_IGN)
{ -- traitement = ignorer le signal Selon les signaux
if (signr != SIGCHLD) continue; - ignorer;
/* Check for SIGCHLD: it's special. */ -Stopper le processus (TASK_STOPPED)
while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0) -Tuer le processus avec ou sans core (do_exit())
continue;

handle_signal(signr);

Méthodes de Programmation Système 2008/2009 J. Delacroix 11


3. Exécution d’un handler de signal défini par l’utilisateur

• Traitement des signaux


Utilisateur
Noyau

main()
{
1
4
}
fonction handler
sig_int
{
2
Co
} 
@
ha @ handler
nd
3 ler

Méthodes de Programmation Système 2008/2009 J. Delacroix 12


3. Exécution d’un handler de signal défini par l’utilisateur

Méthodes de Programmation Système 2008/2009 J. Delacroix 13


NOTIONS DE BASE : traitement d'une exception

Méthodes de Programmation Système 2008/2009 J. Delacroix 14


Les fonctions liées aux signaux

• Envoyer un signal à un processus


– int kill (pid_t pid, int sig) kill (12563, SIGKILL)
– kill -n°signal pid kill -9 12563

• Associer un handler à un signal


– signal(int sig, fonction) signal(SIGINT, p_hand)
– sigaction(int sig, struct sigaction action, NULL)

• Armer une temporisation


– int alarm (int seconds) alarm(10)
– au bout de seconds unités de temps, le signal SIGALRM est
envoyé au processus

• Attendre un signal
– int pause();

Méthodes de Programmation Système 2008/2009 J. Delacroix 15


Primitive sigaction()

• Associer un handler à un signal (POSIX)

int sigaction (int sig, const struct sigaction *p_action,


struct sigaction *p_action_anc)

struct sigaction {void (*sa_handler)(); /* SIG_DFL ou SIG_IGN


ou pointeur sur handler */
sigset_t sa_mask; /* masque sur signaux */
int sa_flags; } /* options… à mettre à NULL */
 

struct sigaction action;


action.sa_handler = p_hand;
sigaction (SIG_INT, &action, NULL);
 

Méthodes de Programmation Système 2008/2009 J. Delacroix 16


Signaux : synthèse
Utilisateur
Noyau
Processus 1 Processus 2

{ {

signal(sig1, handler)
Processus 1
kill (proc1, sig1)
sig1

} 0

handler()
} handler
{

Méthodes de Programmation Système 2008/2009 J. Delacroix 17


Signaux : synthèse
Utilisateur
Noyau
Processus 1 Processus 2

{ {

signal(sig1, handler)
Processus 1
kill (proc1, sig1)
sig1

} 1

Signal pendant
handler()
} handler
{

Méthodes de Programmation Système 2008/2009 J. Delacroix 18


Signaux : synthèse
Utilisateur
Noyau
Processus 1 Processus 2

{ {

signal(sig1, handler)

kill (proc1, sig1)


Processus 1
sig1
}
0
handler() It horloge
} Signal délivré
{
handler
ordonnancement
élection processus 1
examen, traitement signaux
}

Méthodes de Programmation Système 2008/2009 J. Delacroix 19


Signaux et interruptions

• Signaux • Interruptions
 Le processus P2 envoie un  Le dispositif matériel X envoie
signal au processus P1 (signal une interruption lors de
pendant chez P1)
l’exécution du processus P1.

 Plus tard, le processus P1 est


élu. Il quitte le mode noyau. Il  Immédiatement, le processus
exécute le handler du signal P1 est dérouté en mode noyau
en mode utilisateur (signal pour exécuter le handler
délivré à P1). « routine » de l’interruption.

Méthodes de Programmation Système 2008/2009 J. Delacroix 20


/* programme où un processus crée un fichier sur lequel il travaille. En cas de
réception du signal SIGINT, le processus ferme le fichier sur lequel il travaille
avant de se terminer */

#include <sys/types.h> onintr ()


#include <signal.h>
#include <unistd.h> {
#include <stdio.h> printf("Handler onintr\n");
#include <fcntl.h>
close(desc);
int desc; exit ();

main() }
{
int i;
extern onintr(); /* Handler */

desc = open("toto", O_RDWR, 0);


signal (SIGINT, onintr);
i = 0;
while (i < 5)
{ write (desc, "abcdefghijgl", 12);
i = i + 1; }
printf("fin process normal\n");
close (desc);
}
Méthodes de Programmation Système 2008/2009 J. Delacroix 21
/* programme où un processus crée un fils puis se met en attente de la
fin de son fils. Le fils exécute un code qui boucle. Au bout de 10
secondes, le fils n'étant pas achevé, le père tue son fils */

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h> onalarm ()
#include <signal.h> {
pid_t pid;
printf("Handler onalarm\n");
main() kill (pid, SIGKILL);
{
extern onalarm(); /* Handler */ exit ();
}
pid = fork();
if (pid == -1)
printf ("erreur creation de processus");
else
if (pid == 0)
{
printf ("valeur du fork”, pid);
printf (" je suis le fils, mon pid est", getpid());
for(;;)
printf("je boucle !!!! \n");
exit(); }
else {
printf ("valeur du fork", pid);
signal (SIGALRM, onalarm);
alarm(5);
wait (); }
}
Méthodes de Programmation Système 2008/2009 J. Delacroix 22
Programmation clients serveurs
distants

• Modèle clients serveurs


• Interconnexion de réseaux
• Programmation socket

Méthodes de Programmation Système 2008/2009 J. Delacroix 23


Le modèle client-serveur
 
 
  Client Serveur
Requête
envoyer requête ouvrir le service
  attendre réponse Moyen de comunication attendre une requête
  traiter reponse Message - RPC traiter requête
renvoyer réponse
 
 
 
  Requête Serveur Itératif
Un seul processus effectue
la réception, le traitement et
l'émission
Serveur

Serveur Parallèle
Le processus père effectue
Requête la réception. Il crée un fils pour
fork() réaliser le traitement et
thread_create()
l'émission de la réponse.
Serveur
Méthodes de Programmation Système 2008/2009 J. Delacroix 24
L'interconnexion de réseau : quelques principes

M1
M1

R1
R2

R3
RVirtuel RVirtuel
M2
M2

• Construire un réseau virtuel


- adressage (adresse IP, noms symboliques)
- transport de bout en bout (protocole TCP/IP)

Méthodes de Programmation Système 2008/2009 J. Delacroix 25


L'interconnexion de réseau : quelques principes

Structure hiérarchique fondée sur le domaine (DNS) Noms symboliques


objet.sous-domaine.domaine fermi.cnam.fr
Noms de Domaine
objet : nom d'une machine.
domaine : géographique (fr, jp) ou institutionnel (com, mil, edu)
Serveur de noms Résolution de noms

Adresses IP : 32 bits Adresses Internet


Paire (adresse réseau, adresse machine dans le réseau) Adresses IP
Forme pointée : 10000000 00001010 00000010 00011110
128.10.2.30

Résolution d'adresses

Adresses Ethernet
Adresses physiques

Méthodes de Programmation Système 2008/2009 J. Delacroix 26


L'interconnexion de réseau : quelques principes

Machine A Machine B
ports
APPLICATIONS APPLICATIONS
De bout en bout

TRANSPORT TCP UDP Passerelle TCP UDP


Réseau Réseau
RESEAU IP IP IP

INTERFACES INTERFACES INTERFACES

R1
R2

• IP : adressage de machine à machine via adresse IP


• TCP/UDP : adressage d'applications à applications
 notion de ports (entier 16 bits)

Méthodes de Programmation Système 2008/2009 J. Delacroix 27


L'interconnexion de réseau : quelques principes
La couche UDP (User datagram Protocol) APPLICATIONS

• Protocole transport de bout en bout TCP UDP

adressage d'application à application via les ports UDP IP


Ports UDP réservés
exemple : port 513 application who INTERFACES

• Protocole transport non fiable basé sur IP

Datagrammes indépendants
Perte de datagrammes, datagrammes dupliqués, pas de
remise dans l'ordre d'émission

Analogie : le courrier

Méthodes de Programmation Système 2008/2009 J. Delacroix 28


L'interconnexion de réseau : quelques principes

La couche TCP (Transport Control Protocol)


APPLICATIONS

• Protocole transport de bout en bout


TCP UDP

adressage d'application à application via les ports TCP


IP
Ports TCP réservés
exemples : port 21 application ftp INTERFACES

• Protocole transport fiable orienté connexion basé sur IP

Connexion / Flux d'octets


Pas de perte de messages, pas de duplication, remise dans
l'ordre d'émission

Analogie : le téléphone

Méthodes de Programmation Système 2008/2009 J. Delacroix 29


L'interconnexion de réseau : quelques principes

Protocole TCP / UDP

UDP TCP

Echange de datagrammes
Etablissement connexion

Echange de flux d’octets

Fermeture connexion

Méthodes de Programmation Système 2008/2009 J. Delacroix 30


L'interconnexion de réseau : quelques principes

La couche Application
 
 
Création

Inetd
Ecoute

Ecoute

Un démon par service


Encombrement de la table des
processus Le démon inetd
en écoute sur les différents ports
crée le serveur sollicité

Méthodes de Programmation Système 2008/2009 J. Delacroix 31


Les processus démons réseaux

Exemple :

Machine Cliente Machine Serveur


RESEAU
1) Inetd est actif et écoute
le port lié au protocole
Emission d’une requête de service reseau du service

Machine Cliente Machine Serveur


RESEAU
Le serveur inetd
2) détecte la requête sur le
Réception d’une requête du service par le port du service et lance
serveur la démon associé au
service

Machine Cliente Machine Serveur


RESEAU
Le serveur du service
3) communique avec le
Le client et le serveur du service client du service
communique
Machine Serveur
Le serveur du service
Machine Cliente
RESEAU se termine lorsque le
4) service du client a été
réalisé
Fin de la communication entre le client et le serveur

Pendant l’ensemble de ces étapes, le processus inetd est toujours actif.

Méthodes de Programmation Système 2008/2009 J. Delacroix 32


Programmation clients serveurs
distants

• Interface de programmation socket

Méthodes de Programmation Système 2008/2009 J. Delacroix 33


L'interface socket : situation

APPLICATIONS

INTERFACE SOCKETS

TCP UDP

IP

INTERFACES

• Interface de programmation (ensemble de primitives)


• Point de communication (adresse d'application)
• Compatible SGF
Méthodes de Programmation Système 2008/2009 J. Delacroix 34
L'interface socket : création d'une socket

Sock = socket (af, type, protocole)

IPPROTO_TCP
famille Type de se rvice IPPROTO_UDP
TCP-IP---> AF_INET SOCK_STREAM 0
UNIX ---> AF_UNIX SOCK_DGRAM
SOCK_RAW

int socket (af, type, protocole)


int af;
int type;
int protocole;

Retourne un descripteur de socket ayant les mêmes propriétés qu'un


descripteur de fichier ( héritage)
Accessible par le créateur et les fils de celui-ci/

Méthodes de Programmation Système 2008/2009 J. Delacroix 35


L'interface socket : Attachement d'une adresse d'application

in t b in d ( s o c k , p _ a d r e s s e , lg )

d e s c r ip te u r d e la s o c k e t lo n g u e u r d e la
p o in t e u r e n m é m o ir e s u r l'a d r e s s e s tru c tu re a d re s s e
D a n s le d o m a in e T C P /I P
s t r u c t s o c k a d d r _ in

int bind (sock, p_adresse, lg)


int sock;
struct sockaddr_in *p_adresse; -- adresse d'application
int lg;
L'opération d'attachement permet d'étendre le groupe des processus
pouvant accéder à la socket

Méthodes de Programmation Système 2008/2009 J. Delacroix 36


L'interface socket : Attachement d'une adresse d'application

int bind (sock, p_adresse, lg)


int sock;
struct sockaddr_in *p_adresse; -- adresse d'application
int lg;

struct sockaddr_in {
short sin_family; -- AF-INET
ushort sin_port; -- n° de port
struct in_addr sin_addr; -- @ IP
char sin_zero [8]; -- Huit 0
}

Le numéro de port est un entier en dehors des numéros de port


réservés (>IPPORT_RESERVED). Le champ peut être mis à 0 (Choix laissé au
système)

L'adresse Ip de la machine : - constante INADDR_ANY


- utilisation du fichier /etc/hosts
ou serveur de noms
Méthodes de Programmation Système 2008/2009 J. Delacroix 37
L'interface socket : Attachement d'une adresse d'application

/etc/hosts
Correspondance adresse IP et nom symbolique
Adresse IP, nom symbolique, alias, commentaire
163.173.128.6 asimov.cnam.fr cnam iris

Struct hostent {
char *h_name; /* nom de la machine */
char **h_aliases; /* alias */
int h_addrtype; /* type de l'adresse */
int h_length; /* longueur de l'adresse */
char **h_addr_list; /* liste des adresses IP depuis le serveur de
noms */
#define h_addr h_addr_list[0] /* premier élément de
la liste IP */
};

-- obtenir l'entrée /etc/host de la machine de nom "nom"


struct hostent *gethostbyname (nom)
char *nom;
Méthodes de Programmation Système 2008/2009 J. Delacroix 38
L'interface socket : Attachement d'une adresse d'application
nom_serveur
PORTC PORTS

CLIENT SERVEUR

IP client réseau IP serveur

Socket client Socket serveur

Adresse locale
Socket client
Port  PORTC
Adresse IP  INADDR_ANY

Adresse distante
Port  PORTS
Adresse IP  gethostbyname (nom_serveur)
Méthodes de Programmation Système 2008/2009 J. Delacroix 39
L'interface socket : Communication en mode datagramme

Serveur Client

Socket ()

Bind () Socket () Sock = socket (AF_INET,


SOCK_DGRAM, IPPROTO_UDP)
Bind ()

recvfrom()

sendto() Pas d'établissement de connexion

sendto()  Chaque message échangé contient


recvfrom() l'adresse du destinataire

Appels bloquants

Méthodes de Programmation Système 2008/2009 J. Delacroix 40


L'interface socket : Communication en mode datagramme

int sendto(sock, msg, lg, option, p_dest, lgdest)

int sock; -- socket d'émission


char *msg; -- adresse zone mémoire contenant le message
int lg; -- taille en octets du message
int option; -- 0
struct sockaddr_in *p_dest; -- adresse du destinataire
int lgdest; -- taille de l'adresse du destinataire

int recvfrom(sock, msg, lg, option, p_exp, p_lgexp)

int sock; -- socket de réception


char *msg; -- adresse zone mémoire pour recevoir le message
int lg; -- taille en octets du message
int option; -- 0 ou MSG_PEEK
struct sockaddr_in *p_exp; -- adresse de l'expéditeur
int *p_lgdest; -- taille de l'adresse de l'expéditeur

Méthodes de Programmation Système 2008/2009 J. Delacroix 41


L'interface socket : Communication en mode datagramme
/**********************************
* SERVEUR UDP /* Attachement socket */
**********************************/ construit_adresse_locale (adr_s, PORTS) ; --
adresse_ip = INADDR_ANY, port = deuxième
  argument) ;
#include <stdio.h>
#include <sys/types.h> bind(sock, &adr_s, sizeof(adr_s));
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> for (;;)
  {
#define PORTS 2058
main()   lg = sizeof(adr);
{ n = recvfrom (sock, buf, 20, 0, &adr_c, &lg);
int sock;
char buf[20]; printf("Chaine reçue %s\n", buf);
struct sockaddr_in adr_s, adr_c; }
int lg, n;
   
/* Création socket */ close(sock);
sock = socket(AF_INET,SOCK_DGRAM,
IPPROTO_UDP);  
  }
Méthodes de Programmation Système 2008/2009 J. Delacroix 42
L'interface socket : Communication en mode datagramme

/******************/ /* Attachement socket */


/* Client UDP */
/******************/ construit_adresse_locale (adr_c, 0) ; -- adresse_ip
#include <errno.h> = INADDR_ANY, port = deuxième argument ;
#include <sys/types.h> bind(sock, &adr_c, sizeof(adr_c));
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
/* Construction adresse du serveur */
#define PORTS 2058
h=gethostbyname(“fermi.cnam.fr”);
main()
construit_adresse_serveur(adr_s, PORTS, h) ;
{
struct hostent *h; -- adresse_ip = h.addr, port = PORTS
struct sockaddr_in adr_s,adr_c;
sendto(sock, "bonjour, serveur !! ", 20, 0, &adr_s,
char buf[20];
sizeof(adr_s));
int sock;
close (sock);
/* création socket */
}
sock = socket(AF_INET,SOCK_DGRAM,
IPPROTO_UDP);  

Méthodes de Programmation Système 2008/2009 J. Delacroix 43


L'interface socket : Communication en mode connecté
Serveur Client

Socket () Sock = socket (AF_INET,


Bind () Socket () SOCK_STREAM,
Bind () IPPROTO_TCP)
Listen ()

Serveur en attente de connexion


Etablissement de connexion
Connect() avec échange
Accept() des adresses participantes

Connexion établie
Write()
Read ()

Write()  Les messages échangés ne


Read()
contiennent pas l'adresse du
Close() Close() destinataire

Méthodes de Programmation Système 2008/2009 J. Delacroix 44


L'interface socket : Communication en mode connecté
Serveur Client

Sock_ecoute = socket() -- création de la socket d’écoute sock = socket() -- création de la socket


Listen (sock_ecoute, nb)

nb
connect (sock, ....)

sock_service = accept(sock_ecoute,....)

nb
sock_service

read write
Création d’une socket de service sur laquelle
s’effectue les échanges de données

Méthodes de Programmation Système 2008/2009 J. Delacroix 45


L'interface socket : Communication en mode connecté

int listen (sock, nb)


int sock; -- socket d’écoute
int nb; -- connexions pendantes max

int accept (sock, p_adr, p_lgadr) : retourne un descripteur socket de service


int sock; -- socket d'écoute du serveur
struct sockaddr_in *p_addr; -- adresse socket connectée (client)
int *p_lgadr; -- taille de l'adresse

int connect (sock, p_adr, lgadr)


int sock; -- socket client
struct sockaddr_in *p_addr; -- adresse socket du serveur avec lequel
s'établit la connexions
int lgadr; -- taille de l'adresse

Méthodes de Programmation Système 2008/2009 J. Delacroix 46


L'interface socket : Communication en mode connecté

int write (sock, msg, lg)


int sock; -- socket locale
char *msg; -- adresse en mémoire de la zone contenant le message
int lg; -- taille du message en octets

int read (sock, msg, lg)


int sock; -- socket locale
char *msg; -- adresse en mémoire de la zone pour recevoir le
message
int lg; -- taille du message en octets

Méthodes de Programmation Système 2008/2009 J. Delacroix 47


L'interface socket : Communication en mode connecté
Serveur Client

Création Socket d'écoute sock_ecoute Création Socket


et attachement au port et attachement au port

Connect
Listen
BLOQUANT
tant que le serveur
Accept (sock_ecoute) traite une requête

Demande de service
Sock_service Sock_ecoute

Exécution du service Close

Fermeture sock_service
SERVEUR ITERATIF

Méthodes de Programmation Système 2008/2009 J. Delacroix 48


L'interface socket : Communication en mode connecté
Création et attachement de la socket d'écoute sock_écoute
socket / bind

SERVEUR
Ouverture du service PARALLELE
listen

Attente de demande de connexion


Acceptation de la demande
sock_service = Accept (sock_ecoute)

Création d'un processus fils Fork

PERE FILS

Fermeture de la socket d'écoute


Fermeture de la socket de service Traitement de la demande
Exit
Méthodes de Programmation Système 2008/2009 J. Delacroix 49
L'interface socket : Communication en mode connecté
/* Attachement socket */

/********************************** construit_adresse_locale (adr_s, PORTS) ; --


* SERVEUR TCP adresse_ip = INADDR_ANY, port = deuxième
**********************************/ argument) ;
bind(sock, &adr_s, sizeof(adr_s));
 
#include <stdio.h> listen(sock,5);
#include <sys/types.h> /* Boucle d'acceptation d'une connexion */
#include <sys/socket.h>
#include <netinet/in.h> while (TRUE) { /* Attente de question sur la
#include <netdb.h> socket */
  lg = sizeof (adr_c);
#define PORTS 2058
main()   nsock = accept (sock, &adr_c, &lg);
{ pid = fork();
int namelen, sock, nsock;
char buf[20]; if (pid == 0) {
struct sockaddr_in adr_s, adr_c; close (sock);
int lg, n;
  read (nsock, buf, 20);
/* Création socket */ close (nsock);
sock =
socket(AF_INET,SOCK_STREAM, exit();
IPPROTO_TCP); }}}}
  de Programmation Système 2008/2009
Méthodes J. Delacroix 50
L'interface socket : Communication en mode connecté

/******************/ /* Attachement socket */


/* Client TCP */
/******************/ construit_adresse_locale (adr_c, 0) ;
#include <errno.h> -- adresse_ip = INADDR_ANY, port = deuxième
#include <sys/types.h> argument ;
#include <sys/socket.h>
#include <netinet/in.h> bind(sock, &adr_c, sizeof(adr_c));
#include <netdb.h>
#define PORTS 2058
/* Construction adresse du serveur */
main()
h=gethostbyname(“fermi.cnam.fr”);
{
struct hostent *h; construit_adresse_serveur(adr_s, PORTS, h) ;
struct sockaddr_in adr_s,adr_c;
-- adresse_ip = h.addr, port = PORTS
char buf[20];
int sock; connect (sock, &adr_s, sizeof(adr_s));
write(sock, "bonjour, serveur !! ", 20);
/* création socket */
sock = close (sock);
socket(AF_INET,SOCK_STREAM,
}
IPPROTO_TCP);
 

Méthodes de Programmation Système 2008/2009 J. Delacroix 51


L'interface socket : Communication en mode connecté
Création et attachement de la socket d'écoute sock_écoute
socket / bind

SERVEUR
Ouverture du service PARALLELE
listen Le père n’attend
pas son fils.

Attente de demande de connexion


Acceptation de la demande
sock_service = Accept

Création d'un processus fils


Fork

PERE FILS

Fermeture de la socket d'écoute


Fermeture de la socket de service Traitement de la demande
Exit
Méthodes de Programmation Système 2008/2009 J. Delacroix 52
L'interface socket : Communication en mode connecté
Le père n'attend pas ses fils  /* Attachement socket */
handler construit_adresse_locale (adr_s, PORTS) ; --
Signal(SIGCHLD, SIG_IGN); adresse_ip = INADDR_ANY, port = deuxième
/********************************** argument) ;
* SERVEUR TCP bind(sock, &adr_s, sizeof(adr_s));
**********************************/
#include <stdio.h> listen(sock,5);
#include <sys/types.h> /* Boucle d'acceptation d'une connexion */
#include <sys/socket.h>
#include <netinet/in.h> Signal(SIGCHLD, SIG_IGN);
#include <netdb.h>
while (TRUE) { /* Attente de question sur la
 
socket */
#define PORTS 2058
main()   lg = sizeof (adr_c);
{ nsock = accept (sock, &adr_c, &lg);
int namelen, sock, nsock;
pid = fork();
char buf[20];
struct sockaddr_in adr_s, adr_c; if (pid == 0) {
int lg, n; close (sock);
 
read (nsock, buf, 20);
/* Création socket */
sock=socket(AF_INET,SOCK_STREAM, close (nsock);
IPPROTO_TCP); exit();
 
}}}}
Méthodes de Programmation Système 2008/2009 J. Delacroix 53
Programmation clients serveurs
distants

• L’appel de procédure à distance (RPC)

Méthodes de Programmation Système 2008/2009 J. Delacroix 54


Le protocole rpc
C’est un mécanisme général de communication entre processus
dans les systèmes répartis.

• Permettre à un processus de réaliser, au cours de son exécution,


un appel de procédure avec ses paramètres et valeurs de retour
éventuels, dont l’exécution a lieu sur une autre machine.

• Protocole défini chez Sun Microsystems, à la base de


l’implantation du système de fichiers répartis sous Unix, le protocole
NFS (Network File System).

• Ensemble de services s’appuyant APPLICATIONS


sur l’interface des sockets utilisant RPC
le paradigme de l’appel de procédure INTERFACE SOCKETS
en lieu et place des opérations
send et receive
TCP UDP

IP

. INTERFACES

Méthodes de Programmation Système 2008/2009 J. Delacroix 55


Le protocole rpc

• Permettre l'appel de procédures à travers le réseau :


 Modèle client / serveur
 Transparence : comme en local
 Notion de souche/ subrogé (stub) client et serveur

CLIENT
RESEAU SERVEUR
Appel proc (x,y)
Paramètres proc (x,y)

Résultat
Site B
Site A

Méthodes de Programmation Système 2008/2009 J. Delacroix 56


Le protocole rpc

• Les étapes du RPC

Client Souche Client Noyau Noyau Souche Serveur Serveur


Proc(x,y)
Assemblage Déassemblage
des paramètres des paramètres
send receive
x x
y x,y x,y y

Appel Proc(x,y) Proc(x,y)

receive z

z z send Assemblage
Du résultat dans
le message

Méthodes de Programmation Système 2008/2009 J. Delacroix 57


Le protocole rpc

Les difficultés du RPC

Passage de paramètres
par référence

Méthodes de Programmation Système 2008/2009 J. Delacroix 58


Le protocole rpc

Les difficultés du RPC


Panne du réseau : les services idempotents

Client Souche Client Noyau Noyau Souche Serveur Serveur

Assemblage Désassemblage
des paramètres des paramètres
send receive
x x
y x,y x,y y

Appel Proc(x,y) Proc(x,y)

z Assemblage
Du résultat dans
send le message

send

Méthodes de Programmation Système 2008/2009 J. Delacroix 59


Le protocole rpc
Les difficultés du RPC
Panne du réseau : les services idempotents

On réémet la demande à expiration d’un timer, mais le service a


pu être exécuté !
Exemple
• Lecture des 1 024 premiers octets d’un fichier
• Service bancaire : transférer 3 000 euros sur le compte du percepteur

Solution
Placer un numéro de séquence sur les opérations. Le serveur refuse de
refaire deux fois de suite une demande de service portant un même
numéro de séquence

Méthodes de Programmation Système 2008/2009 J. Delacroix 60


Le protocole rpc

Les difficultés du RPC


Panne du serveur : les sémantiques du RPC

Client Souche Client Noyau Noyau Souche Serveur Serveur

Assemblage Désassemblage
des paramètres des paramètres
send receive
x x
y x,y x,y y HS

Appel Proc(x,y) Proc(x,y)

send

Méthodes de Programmation Système 2008/2009 J. Delacroix 61


Le protocole rpc
Les difficultés du RPC
Panne du serveur : les sémantiques du RPC
Serveur Serveur
Appel Proc(x,y) Appel Proc(x,y)

Proc(x,y)
HS
Proc(x,y)
HS
HS

Panne avant ou pendant l’exécution du service  Panne après exécution du service  le service a été exécuté
le service n’ a pas été exécuté

Exécution au moins une fois : la nouvelle demande du client est rééxécutée


Exécution au plus une fois : la nouvelle demande du client est rejetée
Méthodes de Programmation Système 2008/2009 J. Delacroix 62