Cours sur les sockets et pipes (communication entre processus et pc)

[Hydraxx]

## Pipes et sockets sous Windows (IPC et réseau)

Après le filesystem et les I/O, on attaque **la communication**.
Comment deux entités s’échangent des données sous Windows.

Il existe deux grandes familles :

* les **pipes** → communication locale (IPC)
* les **sockets** → communication réseau (ou locale aussi)

Si tu maîtrises ça, tu comprends :

* comment parlent les process entre eux
* comment fonctionnent les serveurs
* comment passent les données sur un système

---

## 1) Pipes vs sockets : la différence

Un **pipe** sert à communiquer :

* entre threads
* entre processus
* sur la même machine

Un **socket** sert à communiquer :

* entre processus
* sur la même machine
* ou à travers le réseau

En résumé :

* pipes = IPC local
* sockets = IPC + réseau

---

## 2) Les pipes sous Windows

### Anonymous Pipes

Les **anonymous pipes** sont simples et anciens.
Ils servent surtout entre :

* un parent
* et un processus enfant

Caractéristiques :

* communication unidirectionnelle
* pas nommés
* héritage de handles

Création :

Code: Select all

HANDLE hRead, hWrite;

CreatePipe(
&hRead,
&hWrite,
NULL,
0
);

Lecture / écriture :

* ReadFile
* WriteFile

Même modèle que les fichiers.

---

### Named Pipes

Les **named pipes** sont beaucoup plus puissants.

Caractéristiques :

* communication bidirectionnelle
* nom global
* plusieurs clients possibles
* basés sur le noyau

Nom typique :
\.\pipe\MonPipe

Création côté serveur :

Code: Select all

HANDLE hPipe = CreateNamedPipeW(
L"\\.\pipe\DemoPipe",
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
4096,
4096,
0,
NULL
);

Attente d’un client :

Code: Select all

ConnectNamedPipe(hPipe, NULL);

Une fois connecté :

* ReadFile
* WriteFile

Côté client :

Code: Select all

HANDLE hPipe = CreateFileW(
L"\\.\pipe\DemoPipe",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL
);

---

### Quand utiliser un named pipe

* communication locale rapide
* IPC structuré
* services Windows
* client/serveur local

C’est très utilisé dans Windows.

---

## 3) Les sockets sous Windows (Winsock)

Les sockets utilisent **Winsock** (API réseau Windows).

Avant tout :

* initialiser la lib
* nettoyer à la fin

Initialisation :

Code: Select all

WSADATA wsa;
WSAStartup(MAKEWORD(2,2), &wsa);

Nettoyage :

Code: Select all

WSACleanup();

---

### Créer un socket

Code: Select all

SOCKET s = socket(
AF_INET,
SOCK_STREAM,
IPPROTO_TCP
);

TCP = SOCK_STREAM
UDP = SOCK_DGRAM

---

### Serveur TCP minimal

Bind :

Code: Select all

sockaddr_in addr = {};
addr.sin_family = AF_INET;
addr.sin_port = htons(4444);
addr.sin_addr.s_addr = INADDR_ANY;

bind(s, (sockaddr*)&addr, sizeof(addr));

Listen :

Code: Select all

listen(s, SOMAXCONN);

Accept :

Code: Select all

SOCKET client = accept(s, NULL, NULL);

---

### Client TCP minimal

Code: Select all

sockaddr_in addr = {};
addr.sin_family = AF_INET;
addr.sin_port = htons(4444);
addr.sin_addr.s_addr = inet_addr("127.0.0.1");

connect(s, (sockaddr*)&addr, sizeof(addr));

---

### Envoyer / recevoir

Code: Select all

send(client, "Hello", 5, 0);
recv(client, buffer, sizeof(buffer), 0);

Ici :

* send / recv
* bloquants par défaut
* similaires à WriteFile / ReadFile

---

## 4) Sockets bloquants vs non bloquants

Par défaut :

* recv bloque
* send bloque

Tu peux :

* passer en non-bloquant
* utiliser select
* utiliser WSAEventSelect
* ou IOCP (niveau avancé)

Exemple non-bloquant :

Code: Select all

u_long mode = 1;
ioctlsocket(s, FIONBIO, &mode);

---

## 5) Pipes ou sockets : que choisir ?

Pipes :

* plus simples
* plus rapides en local
* sécurité via ACL
* intégrés au système

Sockets :

* réseau
* standard
* scalable
* plus complexes

Règle simple :

* IPC local → named pipe
* réseau → socket

---

## 6) Erreurs classiques

Pipes :

* oublier ConnectNamedPipe
* mauvais mode (byte/message)
* handles non fermés

Sockets :

* oublier WSAStartup
* oublier closesocket
* bloquer le thread principal
* mal gérer les erreurs réseau

---

## 7) Points importants à retenir

Pipes :

* utilisent ReadFile / WriteFile
* basés sur des handles
* très proches du filesystem

Sockets :

* utilisent send / recv
* basés sur Winsock
* proches du réseau bas niveau

Les deux sont des mécanismes de communication.
La différence est **le contexte**, pas le principe.

---

## À retenir

Pipes = IPC local
Named pipes = client/serveur local
Sockets = réseau (ou local)
Bloquant par défaut
Toujours gérer les erreurs
Toujours fermer (CloseHandle / closesocket)

Comprendre pipes et sockets, c’est comprendre **comment les programmes parlent entre eux**.

Dans la suite, on pourra voir :

* pipes + threads
* sockets + threads
* ou un modèle serveur propre (thread pool / IOCP)