Serveur TCP
Acceptez les connexions
Serveur TCP est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Construire un serveur TCP
Un serveur TCP attend les clients et accepte leurs connexions. Son cycle de vie est le suivant : créer un socket, l’associer à un port, écouter, puis accepter les connexions dans une boucle.
Étape 1 : créer le socket
Créez un socket de flux pour TCP sur IPv4. Un résultat négatif indique un échec.
#include <sys/socket.h>
#include <stdio.h>
int make_server_socket(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) { perror("socket"); }
return fd;
}Étape 2 : autoriser la réutilisation de l’adresse
Par défaut, un port reste dans l’état TIME_WAIT après l’arrêt du serveur, ce qui empêche les redémarrages. Définissez SO_REUSEADDR avec setsockopt afin de pouvoir associer immédiatement le socket à nouveau.
#include <sys/socket.h>
void allow_reuse(int fd) {
int yes = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
}Étape 3 : associer le socket à un port
bind() associe le socket à une adresse et à un port locaux. INADDR_ANY permet d’écouter sur toutes les interfaces réseau.
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int bind_port(int fd, unsigned short port) {
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
if (bind(fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
perror("bind"); return -1;
}
return 0;
}Étape 4 : écouter
listen() rend le socket passif (prêt à accepter des connexions). L’argument backlog définit le nombre de connexions en attente que le noyau peut mettre en file.
#include <sys/socket.h>
#include <stdio.h>
int start_listen(int fd) {
if (listen(fd, 16) < 0) { /* backlog of 16 */
perror("listen"); return -1;
}
return 0;
}Étape 5 : accepter les connexions
accept() se bloque jusqu’à la connexion d’un client, puis renvoie un nouveau socket pour ce client. Le socket d’origine continue d’écouter.
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
int accept_one(int listen_fd) {
struct sockaddr_in cli;
socklen_t len = sizeof cli;
int conn = accept(listen_fd, (struct sockaddr *)&cli, &len);
if (conn < 0) perror("accept");
return conn;
}Deux sockets, deux rôles
Après accept, vous disposez de deux sockets :
- Le socket d’écoute continue d’accepter de nouveaux clients
- Le socket de connexion communique avec un client précis
Fermez le socket de connexion lorsque vous avez terminé avec ce client.
Lire la requête
Utilisez recv pour lire les données du client dans un tampon. Une valeur de retour égale à 0 signifie que le client s’est déconnecté ; -1 indique une erreur.
#include <sys/socket.h>
#include <stdio.h>
void handle(int conn) {
char buf[256];
ssize_t n = recv(conn, buf, sizeof buf - 1, 0);
if (n > 0) { buf[n] = 0; printf("got: %s\n", buf); }
}Envoyer une réponse
Répondez avec send. Pour les grandes quantités de données, faites une boucle jusqu’à l’envoi de tous les octets, car un seul appel peut n’écrire qu’une partie du tampon.
#include <sys/socket.h>
#include <string.h>
void reply(int conn) {
const char *msg = "hello from server\n";
size_t left = strlen(msg);
const char *p = msg;
while (left > 0) {
ssize_t n = send(conn, p, left, 0);
if (n <= 0) break;
p += n; left -= (size_t)n;
}
}La boucle d’acceptation
Un serveur itératif simple accepte un client, le sert, ferme sa connexion, puis revient en boucle accepter le suivant. Il traite les clients un par un.
#include <unistd.h>
void serve_loop(int listen_fd, int (*accept_one)(int), void (*handle)(int)) {
for (;;) {
int conn = accept_one(listen_fd);
if (conn < 0) continue;
handle(conn);
close(conn); /* done with this client */
}
}Arrêt progressif
Fermez le socket d’écoute lorsque le serveur s’arrête et gérez SIGINT pour quitter proprement la boucle. Fermez toujours les descripteurs afin de libérer les ressources du noyau.
Vérification rapide
Testez votre compréhension des serveurs TCP.
Récapitulatif
Vous avez construit un serveur TCP étape par étape.
- socket, puis SO_REUSEADDR, puis bind, listen et accept
acceptrenvoie un nouveau socket propre à chaque client- recv/send pour communiquer, puis fermeture de la connexion
- Effectuez une boucle pour servir les clients et vérifiez chaque valeur de retour
Questions Fréquemment Posées
La leçon « Serveur TCP » est-elle gratuite ?
Oui — le texte complet de « Serveur TCP » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Serveur TCP » ?
Acceptez les connexions Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Serveur TCP » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.