1.

Les SOCKETS

1. Les SOCKETS .................................................................................................................................................... 1

1.1 Introduction..................................................................................................................................................... 1
1.2 Objectifs du TP................................................................................................................................................2
1.3 Commande Unix associée : netstat..................................................................................................................2
2. Rappels sur le modèle OSI.................................................................................................................................... 3
2.1 L’interface Socket permet de communiquer au niveau 4 (éventuellement 3)................................................. 3
2.2 Encapsulation des données et modèle OSI...................................................................................................... 4
3. Annexe - Utilisation des sockets : fonctions du langage C................................................................................... 5
3.1 Domaines......................................................................................................................................................... 5
3.2 Description des primitives système................................................................................................................. 5

1.1Introduction

Le mécanisme des sockets peut être considéré comme héritant à la fois des fonctions de communication entre
processus et des fonctions de lecture et d'écriture dans un fichier :

• Comme pour un fichier, il sera nécessaire d'ouvrir un canal de communication de type "socket", avant de
pouvoir écrire ou lire des données. A la fin de la session de communication, le canal sera fermé
• Mais ces données seront en fait échangées entre un processus serveur et un processus client, qui résideront
en général sur des machines différentes et quelquefois sur la même machine.

Tableau comparatif des fonctions d'accès au fichiers et de communication via les "sockets" :

Fichiers Sockets
Ouvrir un flux de Fonctions open ou fopen Fonctions socket + bind
données • La cible est un nom de • La cible est définie par
fichier une adresse IP et
un numéro port TCP ou UDP

Plusieurs formats d'adresse sont utilisables, ici

on n'utilisera que le format AF_INET (address
family Internet) qui correspond aux adresses IP.

Le numéro de port correspond au service (par

exemple 23 pour telnet, 21pour ftp ; voir la liste
des services standard dans /etc/services)

• Pour le client : fonction connect

• Pour le serveur : fonctions listen + accept
Envoyer ou écrire des Fonctions write ou fwrite, ou Fonctions write ou send ou sendto ou sendmsg
données dans un flux fprinf ….
Recevoir ou lire des Fonctions read, ou fread, ou Fonctions read ou rcv, ou recvfrom ou
données depuis un flux fscanf …. recvmsg
Fermer une flux de Fonctions close ou fclose Fonctions close ou shutdown
données

Comme on utilisera ici les adresses IP des serveurs, il sera utile d'interroger le DNS depuis un programme en C,
grâce à la fonction gethostbyname.

1/8 Sockets Groupe esaip

Enfin les machines ne codent pas toutes de la même manière les entiers de type short (2 octets)

Codage "big endian" Codage "little endian"

Octet de poids faible – octet de poids fort Octet de poids fort – octet de poids faible

Or il est nécessaire que le numéro de port transmis sur le réseau soit trancrit de la même manière par le serveur et
le client : on utilisera donc les fonctions de conversion htons et ntohs pour réaliser ceci et avoir un code C
identique quelle que soit la machine utilisée.

On pourra vérifier ceci en recompilant le même code sur le dpx20 ou sur une machine Linux, qui utilisent des
codages différents ("big endian" pour les processeurs Intel)

Microsoft(R) Windows 95 On voit ici que l'adresse du

(C)Copyright Microsoft Corp 1981-1996. port imprimante 0378 est
codée 7803 en mémoire
C:\WINDOWS>debug
-d 40:0 Poids fort à la fin
0040:0000 F8 03 F8 02 00 00 00 00-78 03 00 00 00 00 0C 02 ........x.......
0040:0010 27 C4 00 80 02 00 10 20-00 00 3A 00 3A 00 64 20 '...... ..:.:.d

1.2Objectifs du TP

Mettre en œuvre une communication de données entre deux machines Unix via le réseau local
et les protocoles TCP/IP, en utilisant le mécanisme des sockets.

Une des machines agira en tant que serveur pour un numéro de port donné, et l'autre machine
agira en tant que client de cette machine pour le même numéro de port.

Le modèle client-serveur

L'interaction entre applications utilisant les sockets est basée sur le modèle client-serveur:

• Un serveur est un programme offrant un ou plusieurs services en réponse à des requêtes réseau ou
même locales. C'est un processus d'arrière plan (daemon) en écoute des requêtes; lorsqu'une
requête est acceptée et le service correspondant identifié, le serveur crée en général un processus
fils (fork) qui prend en charge la communication avec ce client particulier , alors que le serveur lui-
même retourne à l'écoute d'autres requêtes.
• Un client est un processus qui envoie des requêtes à un serveur local ou réseau et attend la réponse;
en cas d'acceptation, il démarre le transfert de données; d'où le schéma:

1.3Commande Unix associée : netstat

La commande netstat (ou netstat –a) permet de connaître les connexions en cours ou en attente

Connexions Internet actives (serveurs et établies)

Proto Recv-Q Send-Q Adresse locale Adresse distante Etat

tcp 0 0 *:dnp *:* LISTEN

tcp 0 0 *:nfs *:* LISTEN
tcp 0 0 *:ldap *:* LISTEN
tcp 0 0 *:rsync *:* LISTEN
………….
tcp 0 0 localhost:56056 localhost:ldap ESTABLISHED
tcp 0 0 localhost:56053 localhost:ldap ESTABLISHED
tcp 0 0 localhost:ldap localhost:43642 ESTABLISHED
tcp 0 122 localhost:ldap localhost:43645 ESTABLISHED
………….

2/8 Sockets Groupe esaip

 2.Rappels sur le modèle OSI

2.1L’interface Socket permet de communiquer au niveau 4 (éventuellement 3)

7 Application FTP, HTTP, SMTP, Un protocole par service : transfert

POP3, IMAP4, de fichiers, messagerie,
SNMP, RIP, OSPF administration, coordination entre
routeurs, etc…
6 Présentation SSH Cryptage ou compression des
Protocoles OSI données, terminaux virtuels etc…
5 Session Protocoles OSI Définition de points de reprises (ex.
FTP)
Coordination répartie entre moteurs
de Bases de données
4 Transport TCP, UDP, SPX… Premier protocole « de bout en Une adresse de niveau 4 est
bout » un numéro de port
Corrige :
Perte de paquets, duplication de
paquets, désordre dans la séquence
des paquets…
3 Réseau IP, IPX, X25 Spécifie le format d’une adresse Une adresse IP est une
réseau nécessaire pour joindre un adresse de niveau 3
correspondant à travers un réseau de
routeurs
Ne spécifie pas le chemin à utiliser
(c’est le travail spécifique des
application de routage,
implémentées sur les routeurs))
2 Liaison de Ethernet, Permet d’envoyer une trame, avec Si la liaison physique est
données Token Ring correction d’erreurs de transmission multipoint, une adresse de
PPP entre 2 ordinateurs physiquement niveau 2, adresse MAC, est
interconnectés nécessaire pour identifier le
correspondant ( ex. adresse
Ethernet, ou adresse Token
Ring)
1 Physique Ethernet 10base2 Interfaces mécanique, électriques, La liaison physique peut être
Ethernet 10base5 etc.. nécessaires pour coder et établie via un réseau
Ethernet 10baseT transmettre 1 bit de données téléphonique, le Numéro de
Ethernet 100baseT téléphone du FAI peut ainsi
Ethernet 100baseFO être considéré comme une
adresse de niveau 1
Token Ring

RS232 (Modem)

3/8 Sockets Groupe esaip

2.2Encapsulation des données et modèle OSI

Envoi des données par l'application : send() Réception des données par l'application :
receive()
Données
Niveau socket (TCP) Niveau socket (TCP)
Génération de l'entête TCP 4 Analyse de l'entête TCP
et ajout de l'entête TCP aux données et transmisssion des données à l'application
Segment TCP = entête TCP + données
tcp_output() tcp_input()
Génération de l'entête IP 3 Analyse de l'entête IP
et ajout de l'entête IP au segment TCP et trasmisssion du segment TCP au niveau socket
Paquet IP = entete IP + entête TCP + données
ip_output() ip_input()
Génération de l'entête Ethernet 2 Analyse de l'entête Ethernet
et ajout de l'entête Ethernet au paquet IP et transmission de l'entête Ethernet au niveau IP
Trame Ethernet = entête Ethernet + entete IP + entête TCP + données + CRC Ethernet
Emission de la séquence binaire sur le Réception de la séquence binaire sur le support
support de transmission de transmission
1

4/8 Sockets Groupe esaip

 3.Annexe - Utilisation des sockets : fonctions du langage C

3.1Domaines

3.1.1- Types de sockets

Les sockets sont des objets typés. Cette typologie indique la nature de la communication
supportée par la socket:

Les types de base sont :

• SOCK_STREAM: communication en mode connecté, transfert fiable, contrôle de
séquentialité, pas de duplication de paquets (exemple de protocoles: TCP, Transport ISO
etc.).
• SOCK_SEQPACKET: mode connecté orienté séquence de paquets, le format paquet étant
préservé (à un paquet émis correspond un paquet reçu).
• SOCK_DGRAM: communication en mode datagramme, non fiable. sans contrôle de
séquentialité, avec possibilité de duplication (exemple de protocole: UDP).
• SOCK_RAW:communication sans protocole de transport, accès direct aux couches
inférieures. Sockets utilisées dans des progammes de contrôle d'accès à certaines interfaces
ou de diagnostics (ping par exmple).

3.1.2- Domaines de communication

Deux processus communiquant localement ou à distance doivent utiliser les mêmes conventions
d'adressage afin que cette communication soit possible entre sockets en présence. Les domaines
représentent les différents formats d'adressage conventionnels. Ces familles d'adresse dont le choix est
fait dans l'appel socket() sont :
• AF_INET : domaine Intemet de DARPA (voir TCP/IP)
• AF_UNIX : domaine UNIX ou système de fichier UNIX dans lequel un domaine est nommé
par un chemin (pathname).
• AF_ISO : domaine d'adressage ISO (Transport).
• AF_PUP : XEROX PUP Internet
• AF_APPLETALK : Appeltak Network.

3.2Description des primitives système

3.2.1Création d'une socket : socket()

La première chose à faire est de créer une socket par l'appel système socket():

#include <sys/socket.h>
s = socket(af, type, protocol)
int s, af, type protocol;

Paramètres d’entrée :
• af : domaine ou famille d'adresse(AF_INET,AF_UNIX etc..)
• type : type de socket(SOCK_STREAM..).
• Protocole : type de protocole utilisé(TCP,UDP etc..).
Valeur retournée :
• s : Lorsque l'appel socket réussit, un descripteur est retourné, il pointe sur une entrée de la table des
fichiers ouverts qui va pointer à son tour sur une structure dynamique de la socket contenant des
données caractéristiques et de contrôle (protocole, type ...) et sur l'ensemble des routines de
manipulation de la socket. Le descripteur retourné comme tous les descripteurs de fichiers, est hérité
dans les processus fils créés par fork() .

5/8 Sockets Groupe esaip

3.2.2Assignation d'une adresse : bind()
A la création, une socket n'est associée à aucune adresse de port tcp/ip ; Cette asoociation est réalisée
après la création de la socket, par l'appel système bind() .

bind(s, name, namelen)

int s, namelen;
struct sockaddr *name;

Paramètres d’entrée :
• s : descripteur de la socket créée par la primitive socket()
• name : est un chemin ou une structure de type sockaddr permettant de préciser la famille d'adresse,
le numéro de port et l'adresse internet.
• namelen : taille en octets de sockaddr.

3.2.3Demande de connexion: connect()

L'appel connect() permet d'associer une socket à une adresse destination:

connect(s, name, namelen)

int s, namelen;

Paramètres d’entrée :
• s : descripteur de la socket créée par socket()
• name : pointe sur une adresse destination de type sockaddr
• namelen : taille de la structure de type sockaddr

⇒ En mode connecté (protocole TCP par exemple). l'établissement d'une connexion est nécessaire avant tout
échange de données.
⇒ En mode datagramme, connect() indique au 'noyau' la destination des datagrammes à transmettre
ultérieurement.

3.2.4Ecoute des requêtes: listen()

Un serveur doit préparer une socket à l'écoute de connexions entrantes:

listen(s, backlog) /* mode connecté */

int s, backlog ;

Paramètres d’entrées :

• s : descripteur de socket
• backlog : taille de la queue des requêtes entrantes simultanées, la valeur courante du backlog = 4
ou 5;

3.2.5Acceptation des demandes de connexion: accept()

Lorsqu'une requête est acceptée sur la socket s, le serveur en crée une autre ns, sur laquelle se feront les
échanges, alors que le serveur continue d'écouter sur la socket s; addr pointe sur l'adresse client. Les requêtes
sont gérées soit de façon itérative par le serveur qui traite les requêtes une à une en fermant à chaque fois la
socket ns; soit de façon concurrente par un processus fils responsable du service alors que le serveur retourne à
l'écoute. Le fils fermera ns en fin de transfert.

ns = accept(s, addr, addrlen)

int s, ns, *addrlen;

6/8 Sockets Groupe esaip

Paramètres d’entrée :
• s : descripteur socket
• addr : pointeur sur l’adresse client
• addrlen :

Valeur renvoyée :
• ns : descripteur de la nouvelle socket créée

3.2.6Sélection: select()
C'est un service multiple ou multiplexage des descripteurs. Un serveur peut attendre des connexions sur plusieurs
sockets pour gérer plusieurs services; mais il peut également gérer d'autres descripteurs que ceux des sockets
(fonction d'émulation de type remote login gérant une connexion socket et le terminal client...)

#include <sys/time.h>
n_ready = select(ndes, indes, outdes, exdes, timout)
int n_ready, ndes, *indes, *outdes, *exdes;
struct timeval *timout;

Paramètres d’entrée :
• ndes : nombre de descripteurs
• indes, outdes, exdes : pointeurs sur des bits maps permettant de vérifier les descripteurs en
lecture (indes), écriture (outdes) et événements exceptionnels (exdes).

timout : adresse d'un entier indiquant le timout d'attente: une valeur 0 bloque l'appel jusqu'à ce qu'un
descripteur devienne prêt.

3.2.7Emission de données
Plusieurs primitives sont disponibles pour le transfert de données: write() , send() , sendto() , sendmsg()

write()

write(des, buffer, length)

Paramètres d’entrée :
• des : descripteur fichier ou socket.

send()

send(s, msg, len, flags) /* utilisé en mode connecté */

int s;
char *msg; /* communication orientée messages */

Paramètres d’entrée :
• s : descripteur de la socket déjà créée.
• msg : pointe sur le message (séquence d'octets) à transmettre
• flags : contrôle de transmission, les données express par exemple, ou la non utilisation de la table
de routage locale...

sento()

sendto(s, msg, flag, to, tolen)

Paramètres d’entrée :
• to : pointe sur une adresse destination; sendto s'applique aux datagrammes.

7/8 Sockets Groupe esaip

sendmsg()

sendmsg(s, msg, flags)

même chose que sendto mais plus lisible.

3.2.8Réception de données
Les appels système sont similaires à ceux de l'émission de données:

read(des, buffer, length)

rcv(s, buf, len, flags) /* mode connecté */
recvfrom(s, buf, len, flags, from, fromlen)
utilisé en mode datagramme avec "from" pointant sur l'adresse source (du message) de type sckaddr.
recvmsg(s, msg, flags)

3.2.9Fermeture d'une connexion

close(s)

fermeture par un close standard d'UNIX

shutdown(s, how)

cette primitive permet une fermeture partielle ou totale d'une connexion full-duplex
⇒ how = 0 fermeture en réception
⇒ how = 1 fermeture en émission
⇒ how = 2 fetmeture des deux sens de transmission

3.2.10Création d'une paire de sockets (mode connecté)

socketpair(d, type, protocol, sv)
int d, type, protocol, sv[2];

Cette primitive permet de créer une paire de sockets connectées, identifiées par les descripteurs sv [0],
sv[1]; d, type, protocol désignent le domaine, le type et le protocole; c'est une généralisation du pipe simple
d'UNIX mais avec cette différence que chacune des sockets sv[0], sv[1] peut être utilisée en lecture ou en
écriture; la communication entre processus utilisant la paire de sockets se déroule en full duplex.

Diverses autres primitives sont disponibles dont celles bien pratiques permettant d'avoir des informations
sur les hosts, les services, les réseaux et les protocoles:
• gethostbyname(name),
• getservbyname(name, proto),
• getnetbyname(name),
• getprotobyname (name), etc.
Ces différentes primitives retournent un pointeur sur une structure appropriée dont le type est défini
dans /usr/include/netdb.h (hostent, servent, netent, protoent...).
On a dans le même ordre d'idée les primitives:
• gethostname (name, namelen) : nom de la machine locale
• sethostname (name, namelin) : assigner un nom à la machine
• getpeername (s, name, namelen) : nom de la machine partenaire, etc.

8/8 Sockets Groupe esaip