La programmation réseau : les sockets
Partie 2 sur 3
3Les fonctions de l’API, une par une
On décrit les fonctions en langage C, avec leurs paramètres. Les voici, avec leurs rôles et les corrections de détail utiles. Dans tous les cas, une valeur de retour négative (en général -1) signale une erreur sous les systèmes de type UNIX, que l’on écrit parfois SOCKET_ERROR (le nom de la constante de Windows, où elle vaut aussi -1) : il faut la tester à chaque appel.
3.1socket() : créer
int s = socket(famille, type, protocole);
famille:AF_INETpour les adresses du protocole IP version 4 (une adresse IP de 4 octets et un numéro de port, voir les adresses IP) ;AF_INET6pour la version 6 ;AF_UNIXpour des communications locales sur une même machine.type:SOCK_STREAMpour un flux de données avec connexion (TCP),SOCK_DGRAMpour des datagrammes (UDP).protocole: on met0pour laisser le système choisir le protocole normal du type demandé.
La fonction renvoie le descripteur du nouveau socket, ou -1 en cas d’erreur. Un exemple classique est descripteur = socket(AF_INET, SOCK_STREAM, 0), qui reste correct.
3.2bind() : lier à une adresse et un port
int bind(int descripteur, const struct sockaddr *adresse, socklen_t longueur);
Le deuxième paramètre est une structure d’adresse. On décrit la structure générique sockaddr (une famille, puis 14 octets d’adresse) et la structure propre à IP, sockaddr_in, qui contient : la famille (sin_family, toujours AF_INET), le port (sin_port), l’adresse de la machine (sin_addr) et un remplissage de huit octets à zéro (sin_zero, qui sert à donner la même taille que la structure générique). L’adresse IP et le port n’occupent que six octets, d’où ce remplissage. En pratique, on met toute la structure à zéro avant de la remplir, ce qui règle la question du remplissage.
Deux fonctions de conversion s’imposent. Sur le réseau, les nombres sont écrits avec l’octet de poids fort en premier (c’est l’« ordre réseau »), alors que beaucoup de processeurs font l’inverse. htons() (pour un nombre de 16 bits, comme un port) et htonl() (32 bits, comme une adresse) convertissent dans le bon sens. On convertit le port avec htons() dans bind() ; mais on voit parfois htonl(port) au lieu de htons(port) dans un exemple de connect() : c’est une erreur, un port tient sur 16 bits.
Pour l’adresse, deux choix usuels. La constante INADDR_ANY signifie « toutes les adresses de la machine » : le socket accepte alors les connexions qui arrivent par n’importe laquelle des interfaces réseau. À l’inverse, on peut fixer une adresse précise ; la plus utile est l’adresse de boucle locale 127.0.0.1, qui désigne la machine elle-même : un service qui s’y lie n’est joignable que depuis la machine, ce qui convient aux essais et à tout ce qui n’a pas à être exposé. Enfin, on peut demander le port 0 : le système en choisit un libre, que l’on peut relire ensuite.
Les numéros de port en dessous de 1024 sont réservés, sur la plupart des systèmes, aux programmes lancés avec des droits d’administrateur (voir les ports). Pour vos essais, prenez un numéro élevé, entre 49152 et 65535 par exemple, qui sert d’ordinaire aux usages temporaires.
3.3listen() : se mettre à l’écoute (TCP seulement)
int listen(int descripteur, int attente);
Le paramètre attente (backlog en anglais) est le nombre maximal de connexions que le système accepte de garder en file d’attente pendant que le programme s’occupe d’une autre. Cette fonction ne s’emploie qu’en mode connecté. Elle renvoie 0 si tout va bien. Le système plafonne la valeur ; une dizaine suffit pour des essais.
3.4accept() : accepter un appel
int client = accept(descripteur, struct sockaddr *adresse_client, socklen_t *longueur);
La fonction bloque le programme (elle le met en pause) jusqu’à ce qu’un client se connecte, puis renvoie un nouveau descripteur, celui de la conversation avec ce client précis. Le socket d’origine continue d’écouter. Les deux autres paramètres, facultatifs, permettent de connaître l’adresse du client ; on peut passer NULL si elle ne sert pas. En résumé, accept() renvoie « un identificateur du socket de réponse ».
3.5connect() : se connecter à un serveur
int connect(int descripteur, const struct sockaddr *adresse_serveur, socklen_t longueur);
C’est l’équivalent, côté client, de accept(). Le client n’a pas besoin de faire bind() : le système lui attribue de lui-même une adresse et un port temporaire. La fonction renvoie 0 si la connexion est établie, -1 sinon. Pour trouver l’adresse à partir d’un nom comme serveur.example.org, on utilisait gethostbyname(), qui est aujourd’hui obsolète : on lui préfère getaddrinfo(), qui traduit un nom (par le système de noms de domaines, voir le DNS) en adresses IPv4 ou IPv6, et remplit les structures prêtes à l’emploi.
3.6recv() et send() : lire et écrire
ssize_t n = recv(descripteur, tampon, longueur, drapeaux); ssize_t m = send(descripteur, tampon, longueur, drapeaux);
recv() lit des octets reçus dans un tampon (une zone de mémoire que vous avez réservée), dans la limite de longueur. Elle renvoie le nombre d’octets réellement lus, qui peut être inférieur à ce que vous avez demandé. Si elle renvoie 0, l’interlocuteur a fermé la connexion proprement ; si elle renvoie -1, il y a eu une erreur. Comme accept(), elle bloque le programme tant que rien n’est arrivé.
send() écrit des octets. Elle renvoie le nombre d’octets acceptés par le système, qui peut lui aussi être inférieur à ce que vous demandiez : il faut recommencer pour le reste.
Les drapeaux (dernier paramètre) modifient le comportement. On en cite : MSG_PEEK, qui lit sans retirer les données de la file de réception ; MSG_OOB, qui concerne les données « urgentes » (Out Of Band, mécanisme peu utilisé et déconseillé aujourd’hui) ; MSG_DONTROUTE, qui évite le passage par une passerelle ; 0 pour le fonctionnement normal. Pour le mode non connecté, on emploie à la place sendto() et recvfrom(), qui ajoutent l’adresse du correspondant en paramètre.
3.7close() et shutdown() : fermer
close() ferme le socket, en laissant au système le temps d’envoyer les données qui restent (pour TCP). shutdown() ferme dans un seul sens si on le souhaite : le paramètre vaut 0 pour fermer la réception, 1 pour fermer l’émission, 2 pour les deux. Fermer l’émission seulement est très utile : « j’ai fini de parler, mais j’écoute encore la réponse ». Les deux fonctions renvoient 0 en cas de succès, -1 sinon. Sous Windows, la fonction de fermeture d’un socket s’appelle closesocket().
Pour s’exercer
Exercice 1 : remettre les appels dans l’ordre
Un serveur TCP exécute, en désordre : accept, close, listen, recv, socket, bind. Remettez-les dans l’ordre, puis dites ce que fait le client.
Voir la réponse
Serveur : socket, bind, listen, accept, recv, close. Le client appelle socket, puis connect (sans bind, le système lui donne un port), échange avec send et recv, et termine par close.
Exercice 2 : le message coupé
Un client envoie en deux appels les 100 octets d’un message. Le serveur fait un seul recv avec un tampon de 256 octets et obtient 60. Est-ce une erreur ? Que doit faire le serveur ?
Voir la réponse
Ce n’est pas une erreur : TCP ne conserve pas les frontières entre envois, et le système remet ce qui est arrivé. Le serveur doit savoir quand un message est complet : soit le client annonce la longueur (par exemple dans les premiers octets), soit un séparateur marque la fin. Le serveur répète alors recv jusqu’à avoir reçu les 100 octets, en tenant compte du fait que la valeur renvoyée est un nombre d’octets, qui peut valoir moins que demandé.
4Un exemple complet, côté serveur et côté client
Voici un exemple de serveur en mode connecté, en C, très simple, qui renvoie ce qu’il reçoit (un « écho ») et s’appuie sur quelques fonctions utilitaires. Il n’écoute que sur la machine locale, et traite un seul client avant de s’arrêter, ce qui est suffisant pour comprendre.
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int ecoute = socket(AF_INET, SOCK_STREAM, 0);
if (ecoute == -1) { perror("socket"); return 1; }
struct sockaddr_in adr;
memset(&adr, 0, sizeof adr); /* tout à zéro d'abord */
adr.sin_family = AF_INET;
adr.sin_port = htons(50007);
adr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); /* 127.0.0.1 */
if (bind(ecoute, (struct sockaddr *)&adr, sizeof adr) == -1) {
perror("bind"); return 1;
}
if (listen(ecoute, 5) == -1) { perror("listen"); return 1; }
int client = accept(ecoute, NULL, NULL); /* attend un client */
if (client == -1) { perror("accept"); return 1; }
char tampon[256];
ssize_t n = recv(client, tampon, sizeof tampon, 0);
if (n > 0) send(client, tampon, (size_t)n, 0); /* renvoie tel quel */
close(client);
close(ecoute);
return 0;
}
Le programme suit exactement la colonne de gauche de la figure 1. On y voit les bonnes habitudes : la structure est mise à zéro, le port converti par htons(), chaque appel est testé, et la lecture se limite à la taille du tampon (sizeof tampon), jamais davantage.
En Python (voir Python), le même mécanisme tient en quelques lignes, car le langage s’occupe de la plupart des détails. Voici le serveur, puis le client :
# serveur.py
import socket
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as ecoute:
ecoute.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
ecoute.bind(("127.0.0.1", 50007))
ecoute.listen(5)
client, adresse = ecoute.accept()
with client:
donnees = client.recv(1024)
client.sendall(donnees.upper())
# client.py
import socket
with socket.create_connection(("127.0.0.1", 50007)) as s:
s.sendall(b"bonjour")
print(s.recv(1024)) # b'BONJOUR'
Lancez le serveur dans un terminal, puis le client dans un autre : le client affiche le message en majuscules. L’option SO_REUSEADDR évite le message d’erreur « adresse déjà utilisée » quand on relance rapidement le serveur. La méthode sendall() répète les envois jusqu’à ce que tout soit parti, ce qui règle le problème signalé pour send().
4.1Servir plusieurs clients à la fois
Notre serveur d’exemple traite un seul client. Pour l’acceptation de plusieurs connexions, avec les appels fork et select, le problème est le suivant : accept() et recv() bloquent, donc un client lent immobilise tous les autres. Il existe trois grandes réponses :
- Un processus ou un fil d’exécution par client : après
accept(), le serveur lance un nouveau processus (avec l’appelforksous UNIX) ou un fil (un second déroulement du programme dans le même processus) qui s’occupe de ce client, tandis que le principal retourne à l’écoute. C’est simple, mais cela consomme des ressources quand les clients sont nombreux. - Le multiplexage : un seul fil surveille plusieurs sockets à la fois grâce à
select(), ou à ses successeurspoll()etepoll()(Linux). Le système répond « ces trois sockets ont de quoi lire », et le programme ne traite que ceux-là, sans jamais rester bloqué. - Les modèles asynchrones des langages modernes (
asyncioen Python, les boucles d’événements de JavaScript, les « goroutines » de Go), qui reposent en dessous sur le multiplexage.