Partie 6 - Sockets

Support présentation

Introduction

Un socket est un point de communication bidirectionnel entre deux processus. Il peut servir à communiquer localement (AF_UNIX) ou via le réseau (AF_INET pour IPv4, AF_INET6 pour IPv6). Les sockets sont manipulées comme des descripteurs de fichiers (entiers), utilisables avec read/write ou send/recv.

Modes de transport TCP/UDP

• TCP (Transmission Control Protocol) : SOCK_STREAM, mode connecté, fiable, ordonné (handshake, accusés, retransmissions, contrôle de flux et de congestion). Idéal pour HTTP/HTTPS, SSH, SMTP/IMAP/POP3, bases de données.

• UDP (User Datagram Protocol) : SOCK_DGRAM, mode non connecté, non fiable (best-effort), non ordonné, sans retransmission intégrée. Idéal lorsque la latence prime (streaming temps réel, VoIP, jeux).

Source de l’image.

TCP fournit une connexion et une fiabilité, UDP fournit une boîte aux lettres rapide sans garantie. Analogie avec boire de l’eau, avec TCP on est sûr de boire l’eau, avec UDP, on « espère » boire l’eau.

Source de l’image

Pour ce cours, nous utiliserons le mode connecté avec TCP.

Modèle OSI et pile TCP/IP

Les sockets se situent au-dessus des protocoles de transport (TCP/UDP) et exposent une API de programmation.

Source de l’image.

Principe d’un échange d’une communication en mode connecté (TCP)

Une communication TCP met en jeu deux applications distinctes :

• le serveur : attend et accepte les connexions entrantes

• le client : initie la connexion vers le serveur

1. Le serveur doit être lancé avant le client. Il crée un socket (socket), l’associe à une adresse IP et un numéro de port (bind), puis le place en écoute (listen). Quand un client se présente, l’appel accept crée un nouveau socket connecté dédié à ce client.

2. Le client crée aussi un socket (socket) puis tente de se connecter au serveur via connect en précisant l’adresse IP et le port du serveur.

3. Une fois la connexion établie, les deux côtés peuvent échanger des données avec send/recv (ou write/read).

4. Pour terminer, la connexion TCP est fermée proprement avec shutdown et close, ce qui libère les ressources.

À retenir

• listen met simplement le socket serveur en attente, mais ne crée pas la connexion.

• C’est accept qui génère un nouveau socket connecté pour dialoguer avec un client, tandis que le socket d’écoute continue à attendre d’autres connexions.

Source de l’image.

Principe d’un échange d’une communication en mode non connecté (UDP)

Une communication UDP implique également deux applications :

• le serveur : attend les datagrammes sur un port donné

• le client : envoie des datagrammes vers l’adresse et le port du serveur

Contrairement à TCP, aucune connexion persistante n’est établie : chaque envoi est indépendant et peut être perdu ou reçu dans un ordre différent.

1. Le serveur crée un socket (socket) de type SOCK_DGRAM puis l’associe à une adresse IP et un port avec bind. Il utilise ensuite recvfrom pour attendre la réception d’un datagramme, et peut répondre avec sendto.

2. Le client crée aussi un socket (socket), puis envoie un datagramme au serveur avec sendto en indiquant explicitement l’adresse IP et le port de destination. Pour recevoir la réponse, il utilise recvfrom.

3. Chaque envoi ou réception est indépendant : il n’y a pas de notion de session ou de « connexion » comme en TCP.

4. Les sockets UDP se ferment simplement avec close.

À retenir

• UDP ne garantit ni la livraison, ni l’ordre, ni l’absence de doublons.

• C’est le programme qui doit gérer ces aspects si nécessaire (accusés de réception, numéros de séquence, retransmission, etc.).

• Ce manque de fiabilité en contrepartie d’une faible latence en fait un choix adapté au streaming, à la voix sur IP (VoIP) ou aux jeux en ligne.

Source de l’image.

Création d’un socket

Prototype C :

int socket(int domain, int type, int protocol);

• domain : AF_INET (IPv4), AF_INET6 (IPv6), AF_UNIX (local)

• type : SOCK_STREAM (TCP), SOCK_DGRAM (UDP)

• protocol : souvent 0 (choix par défaut selon type)

Retourne -1 si erreur (errno contient le code d’erreur).

Exemple :

// 1. connexion TCP en mode connecté
 int fd = socket(AF_INET, SOCK_STREAM, 0);
 if (fd == -1) {
     perror("socket");
     exit(EXIT_FAILURE);
 }

 // Option SO_REUSEADDR pour éviter "Address already in use", uniquement côté serveur
 int opt = 1;
 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof opt) == -1) {
     perror("setsockopt");
     close(fd);
     exit(EXIT_FAILURE);
 }

Le côté client, comme le côté serveur, doit créer le socket qui retourne un File Descriptor.

Définition des interfaces avec bind

bind permet d’associer un socket à une adresse locale (IP + port ou chemin UNIX). Le serveur doit l’appeler pour réserver l’adresse sur laquelle il écoute. Le client n’a pas besoin de bind, car le noyau lui attribue automatiquement une adresse locale lors de connect ou sendto, toutefois, un client peut appeler bind lorsqu’il veut imposer une adresse ou un port source spécifique.

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• sockfd : descripteur de socket

• addr : pointeur vers la structure d’adresse (cast en struct sockaddr*)

• addrlen : taille de la structure

Retourne 0 si succès, -1 si erreur (errno contient le code d’erreur).

Note

En pratique, on n’utilise pas directement struct sockaddr. On remplit une structure spécialisée (sockaddr_in, sockaddr_in6, sockaddr_un), puis on la cast en struct sockaddr* pour l’appel système.

Note

La fonction htons (Host TO Network Short, htonl pour Long) convertit un entier 16 bits de l’ordre d’octets de la machine (host order) vers l’ordre d’octets du réseau (network order, big-endian). Elle est définie dans <arpa/inet.h>.

Utilisation typique : convertir un numéro de port avant de l’inscrire dans une structure d’adresse sockaddr_in.

Sans cette conversion, le programme pourrait fonctionner par hasard sur une machine little-endian (x86) mais échouer sur une architecture big-endian (ordre mémoire différent).

• Adresse IPv4 (AF_INET - <netinet/in.h>)

  struct sockaddr_in {
     sa_family_t    sin_family;   // AF_INET
     in_port_t      sin_port;     // port en ordre réseau (htons)
     struct in_addr sin_addr;     // adresse IPv4 (htonl ou inet_pton)
     unsigned char  sin_zero[8];  // padding pour compatibilité
  };
  
  struct in_addr {
     uint32_t s_addr; // adresse IPv4 en ordre réseau
  };
  

  Exemple :

  struct sockaddr_in addr = {0};            // met tous les champs de addr à 0
  addr.sin_family      = AF_INET;
  addr.sin_port        = htons(8080);       // port 8080 → ordre réseau
  addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0 → écouter sur toutes les interfaces IPv4
  

• Adresse IPv6 (AF_INET6 - <netinet/in.h>)

  struct sockaddr_in6 {
     sa_family_t     sin6_family;   // AF_INET6
     in_port_t       sin6_port;     // port en ordre réseau (htons)
     uint32_t        sin6_flowinfo; // infos QoS/flux
     struct in6_addr sin6_addr;     // adresse IPv6 (inet_pton)
     uint32_t        sin6_scope_id; // identifiant de zone (interfaces locales)
  };
  
  struct in6_addr {
     unsigned char s6_addr[16]; // adresse IPv6 en binaire
  };
  

  Exemple :

  struct sockaddr_in6 addr6 = {0};
  addr6.sin6_family = AF_INET6;
  addr6.sin6_port   = htons(8080); // port 8080 → ordre réseau
  addr6.sin6_addr   = in6addr_any; // :: → écouter sur toutes les interfaces IPv6
  

• Adresse locale (AF_UNIX - <sys/un.h>)

  struct sockaddr_un {
     sa_family_t sun_family;   // AF_UNIX
     char        sun_path[108]; // chemin du fichier-socket
  };
  

  Exemple :

  struct sockaddr_un addr = {0};
  addr.sun_family = AF_UNIX;
  strcpy(addr.sun_path, "/tmp/mysocket"); // chemin du fichier-socket
  

Exemple complet avec le bind et sockaddr_in :

#define PORT 8080

// 2. Configuration de l'adresse (écoute sur toutes les interfaces, port 8080)
struct sockaddr_in server_addr = {0};
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
server_addr.sin_port = htons(PORT);

// 3. Bind
if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof server_addr) == -1) {
    perror("bind");
    close(server_fd);
    exit(EXIT_FAILURE);
}

Attendre des connexions avec listen

Pour les sockets TCP, le serveur utilise listen pour indiquer qu’il accepte des connexions entrantes :

int listen(int sockfd, int backlog);

• sockfd : socket créée et bindée

• backlog : taille maximale de la file d’attente des connexions

Retourne 0 si succès, -1 si erreur (errno contient le code d’erreur).

Si plusieurs demandes de connexion ont lieu en même temps, elles sont stockées dans une file d’attente.

Exemple :

#define BACKLOG 16

// 5. Listen
if (listen(fd, BACKLOG) == -1) {
    perror("listen");
    close(fd);
    exit(EXIT_FAILURE);
}

Le serveur est maintenant prêt à accepter des clients.

Accepter des connexions avec accept

Un serveur TCP appelle accept pour accepter une connexion ce qui crée un nouveau socket connecté pour le client.

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

• sockfd : descripteur du socket d’écoute

• addr : pointeur vers une structure qui contiendra l’adresse du client connecté

• addrlen : pointeur vers la taille de cette structure

Retourne un nouveau descripteur, distinct du socket d’écoute si succès, -1 si erreur (errno contient le code d’erreur).

Exemple :

// 6. Acceptation d'un client (à faire dans une boucle pour en accepter plusieurs)
struct sockaddr_in client_addr;
socklen_t client_len = sizeof client_addr;

int client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
if (client_fd == -1) {
    perror("accept");
}

// Gérer le client (dans un vrai serveur, utiliser fork/thread/epoll)
handle_client(client_fd, &client_addr);

Connexion à un socket avec connect

Le client appelle connect pour établir la connexion :

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• sockfd : descripteur de la socket du client

• addr : adresse du serveur

• addrlen : taille de la structure

Retourne 0 si succès, -1 si erreur (errno contient le code d’erreur).

Exemple (IPv4 localhost:8080) :

// 2. Configuration de l'adresse du serveur
struct sockaddr_in server_addr = {0};
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);

// Conversion de l'adresse IP texte en binaire
if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
    perror("inet_pton");
    close(fd);
    exit(EXIT_FAILURE);
}

// 3. Connexion au serveur
printf("[Client TCP] Connexion à %s:%d...\n", SERVER_IP, PORT);
if (connect(fd, (struct sockaddr *)&server_addr, sizeof server_addr) == -1) {
    perror("connect");
    close(fd);
    exit(EXIT_FAILURE);
}
printf("[Client TCP] Connecté !\n");

Envoyer et recevoir des données avec send/recv

Ces fonctions permettent d’échanger des données. En TCP, la socket est connectée et l’adresse du pair est implicite. En UDP, on utilise généralement sendto/recvfrom pour préciser l’adresse à chaque envoi/réception (sauf si la socket UDP a été connect-ée pour figer le pair).

send et recv peuvent envoyer/recevoir moins que la taille demandée, il est plus sûr de les utiliser dans une boucle pour garantir d’obtenir le message complet.

En TCP :

int send(int sockfd, const void *buf, size_t len, int flags);
int recv(int sockfd, void *buf, size_t len, int flags);

• sockfd : descripteur de socket connectée

• buf : tampon de données

• len : taille du tampon

• flags : options (souvent 0)

Retourne le nombre d’octets envoyés/reçus ou -1 si erreur.

Exemple (écho simple) :

// envoyer
const char *msg = "Hello\n";
if (send(sock, msg, strlen(msg), 0) == -1) {
    perror("send");
}

// recevoir
char buf[1024];
ssize_t n = recv(sock, buf, sizeof buf - 1, 0);
if (n > 0) {
   buf[n] = 0;
   printf("%s", buf);
}

Fermeture d’un socket

En fin de communication, il faut libérer proprement le socket pour éviter les fuites de ressources et signaler correctement la fin d’échange au pair.

TCP : shutdown puis close

En TCP, la fermeture peut être demi-duplex (on arrête l’envoi mais on continue à recevoir) ou complète. L’API propose :

• shutdown(fd, SHUT_WR) : on n’envoie plus, on peut encore recevoir (half-close)

• shutdown(fd, SHUT_RD) : on ne reçoit plus

• shutdown(fd, SHUT_RDWR) : on n’envoie ni ne reçoit (fermeture logique des deux sens)

• close(fd) : libère le descripteur au niveau du processus

Patron de fermeture conseillé (côté client ou serveur) :

1. Terminer les envois : shutdown(fd, SHUT_WR)

2. Lire jusqu’à EOF (recv qui retourne 0) pour consommer les données restantes.

3. Appeler close(fd) pour libérer la ressource.

Exemple : fermeture TCP propre

printf("\n[Client TCP] Fermeture de la connexion...\n");
shutdown(fd, SHUT_WR); // On n'envoie plus

// Consommer les données restantes jusqu'à EOF
ssize_t n;
while ((n = recv(fd, buffer, sizeof buffer, 0)) > 0) {
    // On ignore les données restantes
}

close(fd);
printf("[Client TCP] Déconnecté.\n");

Sockets locales (AF_UNIX)

Pour la communication locale entre processus, AF_UNIX est très performant (pas de pile IP). Au lieu d’une IP/port, on utilise un chemin de fichier.

#include <sys/socket.h>
#include <sys/un.h>
#include <string.h>

int fd = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un addr = {0};
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, "/tmp/mysock", sizeof addr.sun_path - 1);
bind(fd, (struct sockaddr*)&addr, sizeof addr);

Avec AF_UNIX, il faut fermer puis supprimer le fichier-socket (côté serveur) :

close(fd);            // ferme le descripteur
unlink("/tmp/mysocket");   // supprime le chemin de la socket (sinon fichier persiste)