Unix Com Proc Sockets

Unix : communication inter
processus, sockets
Viviane Gal
CNAM – Département Informatique/Laboratoire CEDRIC
8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

bibliographie
Ce support a été élaboré à partir des références suivantes :
• UNIX
Programmation et communication
Jean-Marie Rifflet, JeanBaptiste Yunès
Editions Dunod
• Cours "Introduction à la communication IPC Internet"
Eric Gressier-Soudan, CNAM-CEDRIC
• Programmation des sockets sous Unix
Hafid Bourzoufi et Didier Donsez – Université de Valenciennes
• Merci à Samia Bouzefrane
Unix : Communication inter
processus, sockets
• Introduction
• Communication par tubes
• Les sockets

Introduction
Unix : communication inter processus, sockets
• Entrées/sorties
– A chaque fichier Unix : i-nœud ou nœud d’index avec
ensemble de caractéristiques du fichier
– Plusieurs types fichiers :

• Fichiers réguliers
• Les répertoires
• Les tubes
• Les fichiers spéciaux
• Les liens symboliques
• Les sockets

Communication par tubes
• Différents types de tubes :
• anonymes
• nommés
• Caractéristiques communes
• Mécanismes de communication
• A priori unidirectionnels (1 entrée en lecture, 1 en écriture)
• Durant son existence possibilité 1 extrémité inaccessible
• La lecture est destructrice
• Communication d’un flot continue (stream par opposition à
datagramme)
• Gestion mode fifo
• Capacité limitée
• Comportement fonction du nombre de lecteurs et du nombre
d’écrivains
Les tubes anonymes (pipes)
• Caractéristiques spécifiques
• Tubes anonymes = 1er mécanisme de communication avec

synchronisation
• Nécessité de disposer d’un descripteur
• Acquisition de descripteurs
– Soit par appel primitive pipe
– Soit par héritage

• Primitive de création : pipe

# include <unistd.h>
int pipe (int *tubeDesc);
• La création d’un tube anonyme =>

• allocation d’un nœud sur disque des tubes
• allocation de 2 entrées dans table des fichiers ouverts et d’un
descripteur dans table descripteurs processus appelant
• tubeDesc correspond à un tableau de 2 entiers

• tubeDesc[0] lecture p[0]
• tubeDesc[1] écriture p[1]

• Schéma des tables du système
Compteur
références
p[0] internes
p[1] 1 rd 2 0 Nœud associé

au tube
1 wr
Table des descripteurs Table des fichiers ouverts
du processus appelant Table des i-nœuds en mémoire
• Schéma du tube
tubeDesc[0]
tubeDesc[1]
read
write

• Opérations non autorisées sur ces tubes
Anonymes signifie sans référence
⇒ Impossible d’appliquer des primitives nécessitant

le nommage
(ex. : open, rename, chmod, …)

• Lecture dans un tube

Primitive read
nb_lu = read(tube[0], buf, TAILLE_BUF);
où
tube[0] : descripteur en lecture
buf : pointeur sur TAILLE_BUF
nb_lu : nombre de caractères lus

• Comment ça marche ?
si le tube ≠ 0 et contient taille caractères
alors primitive extrait du tube min (taille, TAILLE_BUF)
caractères à l’adresse buf
sinon
si nbre écrivains = 0, fin de fichier atteinte alors pas de caractère lu et
renvoie de 0 par primitive
fsi
si nbre écrivains ≠ 0 alors
si lecture bloquante alors processus mis en sommeil jusqu’à
tube non vide ou 0 écrivain
fsi
si lecture non bloquante alors retour immédiat et valeur retour = -1
et errno = EAGAIN
fsi
fsi

• Ecriture dans un tube

Primitive write
nbEcrit = write(tube[1], buffer, taillebuf);
où
tube[1] : descripteur en écriture
buffer : pointeur sur taillebuf
taillebuf : caractères accessibles
Rq : Si le nombre de caractères à écrire < à la taille du tube l’écriture

sera atomique sinon décomposition arbitraire

• Comment ça marche ?
si nbre lecteurs dans tube = 0
alors SIGPIPE délivré au processus écrivain ⇒ terminaison
processus
sinon
si écriture bloquante alors retour primitive vrai que si les n
caractères sont écrits et processus endormi jusqu’à
tube vide
sinon
si n > PIPE_BUF alors retour = nbre < n
si n ≤ PIPE_BUF et nbre emplacements libres ≥ n
alors écriture atomique
si n ≤ PIPE_BUF et nbre emplacements libres < n
alors retour immédiat sans écriture
(renvoi –1 et errno =
EAGAIN)
• Exercice : Ecriture dans un tube sans lecteur
/* usage : ecrivain sans lecteur */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
struct sigaction action;
void handSigpipe(int sig) { printf("Signal SIGPIPE reçu\n");}
main() {
int nbEcriture, tube[2];
action.sa_hendler = handSigpipe;
sigaction(SIGPIPE, &action, NULL);
pipe(tube); close(tube[0]);
if ((nbEcriture = write(tube[1], "A", 1)) == -1)
perror("Write");
else
printf("Retour du write : %d\n", nbEcriture);
}
Exercice :Utiliser un fichier pour faire communiquer

un processus et son père : le fils exécute "ls –l" et
le père "wc –l"
/* tube.c */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
main(int argc, char *argv[])
{
int desc, desc2;
switch (fork()) {
case -1 : perror("fork"); exit(1);
case 0 :
if ((desc=open(argv[1], O_WRONLY|O_CREAT, 0666))== -
1){
perror("open");
exit(2);
}
close(STDOUT_FILENO); /* fermer la sortie standard */
dup(desc); /* STDOUT_FILENO pointe le meme fichier

que desc */
/* dup: cree un nouveau descripteur qui pointe le
meme fichier que desc, de plus le numero choisi
correspond a la premiere entree libre dans la table
des descripteurs, dans ce cas ce sera STDOUT_FILENO
puisque l'entree correspondante est libre */
/* equivalent a : dup2(desc, STDOUT_FILENO); */
close(desc); /* fermer le descripteur desc car il est
inutile */
execlp("ls", "ls", "-l", NULL);

perror("execlp");
exit(1);

default : wait(NULL);
if ((desc2=open(argv[1],O_RDONLY))==-1)
{
perror("open"); exit(2); }
close(STDIN_FILENO);
dup(desc2);
close(desc2);
execlp("wc", "wc", "-l", NULL);
perror("execlp");
exit(1);
}
}

• Autre exercice : le programme traduit la tentative de
lecture d'un processus alors qu'il n'y a pas de rédacteur
/* tube1.c*/
#include <stdio.h>
void main(){
char c;
int p[2];
int nb_lus;
pipe(p); /* creation du tube */

close(p[1]); /* descripteur en ecriture non utilise' è le
fermer*/
if((nb_lus = read(p[0],&c,1)) == -1 ) perror("Erreur
lecture dans tube");
else if(nb_lus==0) printf("Pas de caractere lu \n");
printf("processus termine\n");
}
• Encore un exercice : nouvelle illustration d'un processus
tentant d'écriture alors qu'il n'y a pas de lecteur
/* tube2.c */
#include <stdio.h>
#include <signal.h>
struct sigaction action;
void capture() {printf("\007 SIGPIPE a ete recu par le

processus %d \n", getpid());}
void main() {
int p[2];
action.sa_handler = capture;
sigaction(SIGPIPE,&action,NULL);
printf("Mon pid est %d\n", getpid());

pipe(p);
close(p[0]); /* fermer le descripteur du
tube en lecture */
/*Tentative d'ecriture dans un tube sans

lecteur ==> reception de SIGPIPE */
if( write(p[1],"jsk",3)== -1 )
perror("Erreur ecriture dans tube");
else printf("Je ne dois jamais passer
par la");
}

Le programme que vous allez utiliser maintenant

(pipe1.c) réalise la commande :
ps –l | grep toto
en créant 2 processus qui communiquent via un tube

Les tubes nommés (fifo)
• Introduits sous le nom : fifo
• Permettent aux processus la communication en mode

flot
• Mêmes caractéristiques que tubes anonymes
• En + : référencés dans système de gestion de fichiers

=> utilisation de certaines primitives comme open
• Identifiables via la commande shell ls –l (caractère p)

• Utilisation d'un tube nommé dans le shell
$ mknod nom_tube p
• Mise en œuvre
$ mknod nom_tube p
$ script1 < tube & exécution en arrière-plan
$ script2 > tube
$ wait attente de la fin du script1

Création d'un tube nommé dans un programme
La fonction mkfifo
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *ref, mode_t mode);
Exemple : le modèle producteur-consommateur

avec un tube nommé

Les sockets
• Une socket = point de communication d’où il est

possible d’envoyer des informations ou d’en
recevoir. Il est donc un moyen bidirectionnel
• Comprendre les sockets :

– // avec courrier ou le téléphone (point de contact : boîtes ou poste
téléphonique)
– Socket ≈ points de contact
– Nature des informations en émission ou réception fonction du type de
la socket
– Définition par la notion de domaine de :
• L’ensemble des sockets
• Un ensemble de protocoles de communication

Les sockets
• Caractéristiques principales
– Structure
Socket associée à objet de structure socket dans le fichier
<sys/socketvar.h>
– Type
• Détermine la sémantique des communications
• Associe un ensemble de propriétés (fiabilité, séquencement, …)
• Fichier standard <sys/socket.h> contient les définitions des
constantes symboliques
– Domaine
• Définit le format des adresses
• Définit un ensemble de protocoles
• Certains domaines prédéfinis se trouvent dans le fichier
<sys/socket.h>

Les sockets
• Tableau de différents types de sockets

Symbole Caractéristiques principales de la socket
SOCK_RAW Orientée vers l’échange de datagrammes (niveau bas de
protocole – ex. : IP)
SOCK_DGRAM Orientée vers la transmission de datagrammes structurés en
mode non connecté sans fiabilité
SOCK_STREAM Orientée vers l’échanges de séquences continues de caractères
SOCK_RDM Orientée vers la transmission de datagrammes en mode non
connecté avec maximum de fiabilité
SOCK_SEQPACKET Orientée vers la transmission de datagrammes en mode connecté
• Exemple de domaines
Nom symmbolique Domaine Format adresses
AF_UNIX ou AF_LOCAL Local sockaddr_un (fichier <sys/un.h>
AF_INET Internet sockaddr_in (fichier <netinet/in.h>
AF_NS Xerox NS Sockaddr_ns (fichier <netns/ns.h>

Les sockets
• Primitives générales
– Création d’une socket : socket
int socket(int domaine, int type, in protocole);
– Suppression d’une socket

∃ une socket tant que le dernier descripteur est non fermé
(par appel à la primitive close)
– Attachement d’une socket : bind

int bind(int descripteur, struct sockaddr *p_adresse, int
longueur);
C’est le bind qui associe la socket à une adresse.

Les sockets
• Exercice sur la création des sockets de différents types et domaines
/* usage : socket */
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
Main( ) {
int desc[5]; // tableau des descripteurs
if ((desc[0] = socket(AF_UNIX, SOCK_STREAM, IPPROTO_TCP)) = = -1)
perror("[AF_UNIX, SOCK_STREAM, IPPROTO_TCP]");
else printf("socket [AF_UNIX, SOCK_STREAM, IPPROTO_TCP] créée: %d\n", desc[0]);
if ((desc[1] = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) = = -1)
perror("[AF_INET, SOCK_STREAM, IPPROTO_TCP]");
else printf("socket [AF_INET, SOCK_STREAM, IPPROTO_TCP] créée: %d\n", desc[1]);
if ((desc[2] = socket(AF_INET, SOCK_DGRAM, 0)) = = -1)
perror("[AF_INET, SOCK_DGRAM, 0]");
else printf("socket [AF_INET, SOCK_DGRAM, 0] créée: %d\n", desc[2]);
if ((desc[3] = socket(AF_INET, SOCK_RAW, IPPROTO_IP)) = = -1)
perror("[AF_INET, SOCK_RAW, IPPROTO_IP]");
else printf("socket [AF_INET, SOCK_RAW, IPPROTO_IP] créée: %d\n", desc[3]);
if ((desc[4] = socket(AF_NS, SOCK_SEQPACKET, 0)) = = -1)
perror("[AF_NS, SOCK_SEQPACKET, 0]");
else printf("socket [AF_NS, SOCK_SEQPACKET, 0] créée: %d\n", desc[4]);
}
Communication via les sockets
• Par datagrammes
Sockets du type SOCK_DGRAM
• En mode connecté
Socket du type SOCK_STREAM

Communication par datagrammes
• Opérations à réaliser
• Demande création d'une socket dans le domaine

adapté
• Demande attachement de la socket sur port convenu
ou quelconque
• Construction de l'adresse interlocuteur en mémoire
• Envoi et réception de messages

• Squelette serveur UDP

/* usage : serveurUDP port commande */
#include "creerSocket.h"
struct sockaddr_in adresse;

short port; int desc;
main(int argc, char *argv[]) {

if (arg != 3) {
fprintf(stderr, "Nombre de paramètres incorrect\n");
exit(2);
}
/* test d'existence du programme à exécuter par le serveur */
if (access(argv[2], X_OK) != 0) {
fprintf(stderr, "Fichier %s non accessible pour exécution\n", argv[2]);
exit(2);
}
• Suite squelette serveur UDP
/* détachement du terminal */
if fork() != 0 exit(0); // après création du fils, le processus se termine
setsid(); // création d'une nouvelle session
printf("serveur de pid %d lancé\n", (int)getpid());
port = atoi(argv[1]); // décodage du numéro de port donné en paramètre
/* création et attachement de la socket du service */

desc = creerSocket(SOCK_DGRAM, port, &adresse);
if (desc = = -1) {
fprintf(stderr, "Création de la socket impossible\n");
exit(2);
}
/* redirection de l'entrée standard de la socket */
dup2(desc, STDIN_FILENO);
/* dup2(desc, STDOUT_FILENO); */ // éventuellement (variante)
/* dup2(desc, STDERR_FILENO); */ // éventuellement (variante)
close(desc); // fermeture du descripteur inutilisé
execlp(argv[2], argv[2], NULL); // recouvrement par la commande donnée
}
• Squelette client UDP
/* à lier à un objet contenant la définition de la fonction serviceClient */
/* usage : machine_serveur port_serveur … */
#include "creerSocket.h"
#include <netdb.h>
#include <string.h>
struct sockaddr_in adresse_serveur, adresse_client;
extern void serviceClient(int, struct sockaddr_in *, int, void **);
main(int argc, char *argv[]) {
int sock; // descripteur de la socket du client
struct hostent *hp; // pour l'adresse de la machine serveur
/* contrôle du nombre de paramètres */
if (argc < 3) {
fprintf(stderr, "erreur sur le nombre de paramètres\n"); exit(2);
}
/* recherche de l'adresse Internet de la machine du serveur */
if (hp = gethostbyname(argv[1])) = = NULL) {
fprintf(stderr, "machine %s inconnue\n", argv[1]); exit(2);
}

• Suite squelette client UDP
/* Création et attachement de la socket du client sur un port quelconque */

sock = creerSocket(SOCK_DGRAM, 0, &adresse_client);
if (sock = = -1) {
fprintf(stderr, "Création socket du client impossible\n"); exit(2);
}
printf("Client lancé sur le port %d\n", nthos(adresse_client.sin_port));
/* Préparation de l'adresse du serveur */

adresse_serveur.sin_family = AF_INET;
adresse_serveur.sin_port = htons(atoi(argv[2]));
memcpy(&adresse_serveur.sin_addr.s_addr, hp->h_addr, hp->h_length);
/* appel de la fonction spécifique au service */

serviceClient(sock, &adresse_serveur, argc-3, argv+3);
}

• Envoi de message
Appel de la fonction sendto
int sendto(int descripteur, void *message, int longueur, int option,
struct sockaddr *p_adresse, int lg_adresse);
La valeur de retour = nbre de caractères du msg envoyé
La primitive sendmsg
int sendmsg(int descripteur, struct msghdr *msghdr, int option);
L'appel à cette fonction permet de transmettre un message constitué

• Lecture de message
La primitive recvfrom
int recvfrom(int descripteur, void *message, int longueur, int option,
struct sockaddr *p_adresse, int p_lg_adresse);
Elle permet de lire sur la socket un message et d'en récupérer le contenu.
La primitive recvmsg
int sendmsg(int socket struct msghdr *msghdr, int option);
cette fonction permet de récupérer un message reçu sur la socket spécifiée.

• Pseudo-connexions
La primitive connect
int connect(int descripteur, struct sockaddr *p_adresse, int lg_adresse);
Une socket pseudo-connectée oblige l'envoi et la réception sur la

socket de la pseudo-connexion.

Communication en mode connecté
Ce mode est associé aux sockets de type SOCK_STREAM.

Il peut être comparé au téléphone.
• Communication entre 2 points spécifiques
• Connexion (circuit virtuel) entre 2 entités
• Protocole = TCP (Transmission Control Protocol)

• Etablissement de la connexion
– Côté serveur TCP
Création d'une socket : socket
Attachement de la socket : bind

Processus ou thread
principale
Ouverture du service : listen
Acceptation d'une connexion pendante : accept
Création d'un processus (ou d'une thread) : fork (ou pthread_create)

nouveau processus ou nouvelle thread
Gestion du dialogue avec le client

• La primitive listen
int listen(int desc, int nb_pendantes);
Elle permet de déclarer l'ouverture d'un service auprès de son système

local.
nb_pendantes = nbre de connexions acceptables
• La primitive accept
int accept(int descripteur, struct sockaddr *ptr_adresse, int *p_lg);
Cette fonction permet à un processus de prendre connaissance de

l'existence d'une nouvelle connexion avec la socket d'écoute.
Cet appel est normalement bloquant.

• Etablissement de la connexion
– Côté client
Création d'une socket : socket
Attachement de la socket sur

un port quelconque : bind
Construction de l'adresse du serveur

(n° port supposé connu)
Demande de connexion avec le serveur : connect
Échec réussite
Dialogue avec le serveur

• Dialogue client/serveur
Entité Entité
TCP TCP
Tampon de réception Tampon d'émission
Réseau
physique
Caractère urgent écriture

lecture
lecture
écriture Caractère urgent
socket
socket
Tampon d'émission Tampon de réception

• Fermeture de connexion
La primitive close
#include <unistd.h>
int close(int descripteur);
Elle ferme le descripteur du processus (désalloue l'entrée de la table des

descripteurs).
La primitive shutdown
#include<sys/socket.h>
int shutdown(int desc, int sens);
Où sens = niveau de fermeture souhaité (ex. : la valeur SHUT_RD ferme

l'extrémité de la connexion en réception)

• Exercice (Merci à Eric Gressier-Soudan)

• Prendre les sources dans /users/ensinf/viviane/socket
• Les placer dans deux répertoires différents
• Ouvrir une fenêtre sous Linux
• Modifier Makefile (car sockets natives)
• Ouvrir une fenêtre sous Solaris
• isockl.c (serveur sockets AF_INET connecté)

• isockt.c (client sockets AF_INET connecté)

• Exercice
• Compiler par make sur chaque machine

• Lancer le serveur sous Linux
• Lancer le client sous Solaris
• Modifier le texte du client affiché par le serveur

• Tester
• Echanger votre texte avec le serveur d'un autre binôme
• Après le getsockname, enlever la conversion ntohs avant

affichage à l'écran sur le serveur et essayer une connexion avec
les deux numéros de port affichés. Que constatez-vous ?
• Transformer le serveur pour qu'il se remette en attente d'une

nouvelle requête au lieu de s'arrêter (passer d'un serveur "à un
coup" à un serveur itératif). Tester

Unix Com Proc Sockets

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Unix Com Proc Sockets

Transféré par

Droits d'auteur :

Formats disponibles

Unix : communication inter

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Communication par tubes

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

– Plusieurs types fichiers :

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Tubes anonymes = 1er mécanisme de communication avec

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Primitive de création : pipe

• La création d’un tube anonyme =>

• tubeDesc correspond à un tableau de 2 entiers

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

p[1] 1 rd 2 0 Nœud associé

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Opérations non autorisées sur ces tubes

Anonymes signifie sans référence

⇒ Impossible d’appliquer des primitives nécessitant

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Lecture dans un tube

nb_lu = read(tube[0], buf, TAILLE_BUF);

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Ecriture dans un tube

nbEcrit = write(tube[1], buffer, taillebuf);

Rq : Si le nombre de caractères à écrire < à la taille du tube l’écriture

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

Exercice :Utiliser un fichier pour faire communiquer

close(STDOUT_FILENO); /* fermer la sortie standard */

dup(desc); /* STDOUT_FILENO pointe le meme fichier

execlp("ls", "ls", "-l", NULL);

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

pipe(p); /* creation du tube */

struct sigaction action;

void capture() {printf("\007 SIGPIPE a ete recu par le

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

/*Tentative d'ecriture dans un tube sans

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

Le programme que vous allez utiliser maintenant

en créant 2 processus qui communiquent via un tube

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Introduits sous le nom : fifo

• Permettent aux processus la communication en mode

• Mêmes caractéristiques que tubes anonymes

• En + : référencés dans système de gestion de fichiers

• Identifiables via la commande shell ls –l (caractère p)

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Utilisation d'un tube nommé dans le shell

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

Création d'un tube nommé dans un programme

Exemple : le modèle producteur-consommateur

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Une socket = point de communication d’où il est

• Comprendre les sockets :

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Tableau de différents types de sockets

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

– Suppression d’une socket

– Attachement d’une socket : bind

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

8, 9 et 11 décembre 2004 Département Informatique - Cycle probatoire - Projet CDI 2004/2005

• Demande création d'une socket dans le domaine