Les sockets · TCP / UDP

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 What is difference between Semaphore and Mutex

  HowTo · 07:00 · 293k vues — Mutex is a object owned by thread who is executing in critical section whereas semaphore is a signaling mechanism.

• 🇫🇷 Semaphore Vs. Mutex - A Clear Understanding

  Shriram Vasudevan · 10:14 · 101k vues — Here you go.. The clear differences between Semaphore and Mutex. All the technical aspects are discussed with examples for each.

• 🇬🇧 What is difference between Semaphore and Mutex

  HowTo · 07:00 · 293k vues — Mutex is a object owned by thread who is executing in critical section whereas semaphore is a signaling mechanism.

1. Qu'est-ce qu'une socket ?

Une socket est un point de communication (extrémité) par lequel un processus peut émettre / recevoir des données (messages) à destination / en provenance d'un autre processus.

Étendue — familles de protocoles

• AF_INET — Internet
• AF_UNIX — Fichiers locaux
• OSI, SN, DEC, CCITT (X25), Appletalk…

Modèle Client / Serveur

2. Adressage TCP/IP

Chaque ordinateur (machine) possède une adresse Internet (IP) unique composée de 32 bits. L'adresse IP contient assez d'information pour identifier de façon unique un réseau donné et un ordinateur spécifique sur le réseau.

Exemples : 132.227.104.15, 193.49.30.38.

Nom de domaine — hiérarchique

• Code d'identification de l'organisation (com commercial, edu éducation, gov gouvernement…)
• Code d'identification du pays (fr, ca, us…)
• Code d'identification d'un sous-domaine (univ-cergy)
• Nom de la machine hôte (www)
• Exemple : www.formadep.fr

La structure sockaddr_in (AF_INET)

Désignation spécifique permettant d'être identifié de l'extérieur. Structure décrite dans le fichier <netinet/in.h>.

struct sockaddr_in {
    short            sin_family;   // AF_INET
    unsigned short   sin_port;     // numero de port (htons)
    struct in_addr   sin_addr;     // adresse IP
    char             sin_zero[8];  // padding
};

3. TCP vs UDP

Types de sockets

4. Enchaînement des primitives

Deux scénarios — mode connecté (TCP, SOCK_STREAM) et mode non connecté (UDP, SOCK_DGRAM).

Cycle TCP — serveur (socket → bind → listen → accept) et client (socket → connect → send/recv → close).

5. Les primitives — prototypes

socket() — créer une socket

Permet de créer une socket (descripteur de socket) pour établir un canal de communication.

int socket(int domain, int type, int protocol);
// domain   : AF_INET, AF_UNIX, ...
// type     : SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_SEQPACKET
// protocol : 0 (auto), IPPROTO_TCP, IPPROTO_UDP

bind() — informations locales

Permet d'associer un nom ou une adresse et un numéro de port au descripteur de socket retourné par socket(). Ses arguments sont :

• le descripteur s de la socket considérée ;
• un pointeur addr vers une structure qui contient l'adresse ou le nom assigné et le numéro de port utilisé ;
• la taille namelen de la structure vers laquelle pointe addr.

int bind(int s, struct sockaddr *addr, socklen_t namelen);

listen() — file d'attente

Longueur maximum de la file d'attente des communications en cours d'établissement.

int listen(int s, int backlog);

connect() — pseudo-connexion (client)

Établissement de la (pseudo-)connexion en renseignant la socket pour le destinataire.

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

accept() — connexions acceptables (serveur)

Définition de l'ensemble des connexions acceptables.

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

recv() / read() — réception

Réception de données — strictement identique à l'appel système habituel read. Autres primitives similaires à read.

ssize_t read (int s, void *buf, size_t n);
ssize_t recv (int s, void *buf, size_t n, int flags);
ssize_t recvfrom(int s, void *buf, size_t n, int flags,
                 struct sockaddr *from, socklen_t *fromlen);

send() / write() — émission

Émission de données — identiques ou similaires à l'appel système write.

ssize_t write (int s, const void *buf, size_t n);
ssize_t send  (int s, const void *buf, size_t n, int flags);
ssize_t sendto(int s, const void *buf, size_t n, int flags,
               const struct sockaddr *to, socklen_t tolen);

close() — libération

int close(int s);

6. Conversions — noms, adresses, byte order

gethostname() — nom de la machine locale

#include <unistd.h>
#include <stdio.h>

int main() {
    char hostname[256];

    if (gethostname(hostname, sizeof(hostname)) == 0) {
        printf("Nom d'hote : %s\n", hostname);
    } else {
        perror("gethostname");
    }

    return 0;
}

gethostbyname() — résoudre un nom en IP

Paramètre d'entrée : le nom de la machine. Valeur de retour : pointeur vers une structure hostent en cas de succès, NULL en cas d'erreur.

struct hostent {
    char  *h_name;       // nom officiel de l'hote
    char **h_aliases;    // liste d'alias
    int    h_addrtype;   // type d'adresse (AF_INET)
    int    h_length;     // longueur de l'adresse
    char **h_addr_list;  // liste d'adresses IP
};

#include <netdb.h>
#include <stdio.h>
#include <arpa/inet.h>

int main() {
    struct hostent *host = gethostbyname("www.google.com");

    if (host == NULL) {
        perror("gethostbyname");
        return 1;
    }

    printf("Nom : %s\n", host->h_name);

    char *ip = inet_ntoa(*(struct in_addr *)host->h_addr_list[0]);
    // inet_ntoa() sert a convertir une adresse IP IPv4 binaire en chaine
    // de caracteres lisible.

    printf("IP : %s\n", ip);
    return 0;
}

gethostbyaddr() — DNS inverse

Fonction qui permet de résoudre une adresse IP en nom d'hôte (DNS inverse).

struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);
// addr : pointeur vers l'adresse IP (binaire)
// len  : taille de l'adresse
// type : AF_INET (IPv4) ou AF_INET6 (IPv6)

#include <netdb.h>
#include <arpa/inet.h>
#include <stdio.h>

int main() {
    struct in_addr addr;
    addr.s_addr = inet_addr("100.10.20.5");
    struct hostent *host = gethostbyaddr(&addr, sizeof(addr), AF_INET);

    if (host != NULL) {
        printf("Nom d'hote : %s\n", host->h_name);
    } else {
        perror("gethostbyaddr");
    }

    return 0;
}

getsockname() — adresse IP d'une socket

Obtenir l'adresse IP d'une socket dont on connaît le descripteur.

int getsockname(int s, struct sockaddr *name, socklen_t *namelen);

Little vs Big Endian

Les quatre fonctions de conversion

7. Exemple TCP — Serveur

Échange de messages client / serveur. Partie serveur.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 8080           // Le port d'ecoute
#define BUFFER_SIZE 1024    // Taille du buffer de reception

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    char buffer[BUFFER_SIZE] = {0};

    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("Erreur lors de la creation du socket");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;   // Accepte les connexions sur n'importe quelle adresse
    address.sin_port = htons(PORT);

    // Lier le socket a l'adresse et au port
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("Erreur de binding");
        exit(EXIT_FAILURE);
    }

    // Ecouter les connexions entrantes
    if (listen(server_fd, 3) < 0) {
        perror("Erreur lors de l'ecoute");
        exit(EXIT_FAILURE);
    }
    printf("En attente de connexion...\n");

    new_socket = accept(server_sd, clien_address, sizeof(client_address));

    // Lire le message du client
    read(new_socket, buffer, BUFFER_SIZE);
    printf("Message du client : %s\n", buffer);

    // Repondre au client
    char *response = "Message recu!";
    send(new_socket, response, strlen(response), 0);
    printf("Reponse envoyee au client\n");

    close(new_socket);
    close(server_fd);
    return 0;
}

8. Exemple TCP — Client

Partie client.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

#define SERVER_IP "127.0.0.1"   // Adresse IP du serveur
#define PORT 8080               // Le port d'ecoute
#define BUFFER_SIZE 1024        // Taille du buffer de reception

int main() {
    int int sock = 0;
    struct sockaddr_in server_address;
    char buffer[BUFFER_SIZE] = {0};

    // Creation du socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("Erreur lors de la creation du socket");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_port   = htons(PORT);

    // Se connecter au serveur
    if (connect(sock, (struct sockaddr*)&server_address, sizeof(server_address)) < 0) {
        perror("Erreur lors de la connexion");
        exit(EXIT_FAILURE);
    }

    // Envoyer un message au serveur
    char *message = "Bonjour, serveur !";
    send(sock, message, strlen(message), 0);
    printf("Message envoye au serveur\n");

    // Lire la reponse du serveur
    read(sock, buffer, BUFFER_SIZE);
    printf("Reponse du serveur : %s\n", buffer);

    // Fermer le socket
    close(sock);
    return 0;
}

9. Connexions concurrentes

Pour qu'un serveur traite plusieurs clients en parallèle, on combine l'API socket avec les techniques de concurrence vues en début de semestre.

Avec fork()

Schéma : Création/attachement (socket/bind) → Ouverture du service (listen) → Attente de la demande de connexion (accept) → Création d'un processus fils (fork) → traitement de la demande du client.

Avec un thread

Variante : à chaque accept() réussi, le programme courant crée un thread qui prend en charge le traitement de la demande du client. Le pattern est identique, on remplace fork() par la création de thread.

★ Réviser le chapitre

❓ Q/R — pour vérifier ta compréhension

🃏 Flashcards éclair

Clique pour retourner. Tout retourner

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

sin_family  // AF_INET
sin_port    // htons(PORT)
sin_addr    // s_addr = IP
sin_zero[8] // padding

✎ Quiz éclair

📌 À retenir