Cours sur la programmation réseau

Bonjour à tous,

je vous présente un projet que je mène actuellement, à savoir l'écriture d'un cours de programmation réseau, sur l'utilisation de la bibliothèque socket, en C++.
Il s'agit de la version réécrite et améliorée d'un cours que j'ai dispensé aux étudiants de l'ESGI Paris en 2015.
Le but de cette série est de démystifier l'utilisation du réseau et de vous permettre d'en profiter dans vos applications.

Chaque partie présente simplement une composante (connexion, envoi de données…) et vous permet de comprendre son fonctionnement, puis de la mettre en pratique immédiatement, via un TP et des codes sources fournis.
À la fin de cette série, vous serez en possession des briques élémentaires nécessaires à la mise en place d'échanges réseau dans votre programme, sous forme de classes C++ utilisant l'API socket de votre système.

Dans un premier temps, nous apprendrons à appréhender les échanges en TCP, d'abord en tant que simple client, puis comme serveur.
Ensuite nous verrons l'utilisation d'UDP.
L'utilisation de threads et mutex sera également abordée.
Enfin certaines techniques plus spécifiques aux jeux vidéos seront présentées sous forme d'articles, publiés dans la section idoine.

Les articles seront diffusés au fur et à mesure de leur (ré)écriture. Retrouvez-les ci-dessous.
Introduction
:fleche: TCP
- Premiers pas
- Envoi et réception
- Mise en place du protocole
- Premiers pas en tant que serveur
- Envoi et réception depuis le serveur
- Mode non bloquant pour le client
- Quelle architecture de client visée ?
- Un premier serveur : miniserveur

:fleche: UDP
- Premiers pas
- Gérer les pertes et duplications d'identifiants
- S'assurer du bon fonctionnement de son code
- Créer son protocole par-dessus UDP
- Découper et réunifier des paquets & création d'un protocole ordonné non fiable
- Envoi de paquets ordonné fiable
- Combiner tous les protocoles : les canaux de communication
- Gérer des connexions entre machines
- Debugger une application en réseau

:fleche: Jeux
- Un premier jeu : Morpion

:fleche: Divers
- Multi-threading et mutex
- Bases de la sérialisation
- Sérialisation de bits
- Sérialisation avancée

:fleche: Retrouvez tous les cours et tutoriels C++ de Developpez.com

quand vous en serez à l'UDP. si vous voulez faire un cas pratique avec de l'audio,
je vous invite à faire un exemple d'implémentation VBAN (avec mon support si besoin).
plus d'info: http://vb-audio.pagesperso-orange.fr...eeter/vban.htm

Voici la première partie plus concrète.
Commençons par les échanges via protocole TCP, du point de vue du client dans un premier temps.
Au programme : création de socket, connexion à un serveur dont on connait l'IP et passage en revue de quelques fonctions utiles de manière générale.

:fleche: http://bousk.developpez.com/cours/re...-premiers-pas/


:fleche: Retrouvez tous les cours et tutoriels C++ de Developpez.com

Après la mise en bouche assez conséquente, voyons maintenant comment envoyer et recevoir des données via un socket TCP préalablement connecté.
Cette courte partie présente les fonctions send et recv dont nous verrons l'utilisations de manière plus poussée dans la partie suivante qui arrive très bientôt.

:fleche: http://bousk.developpez.com/cours/re...voi-reception/

Partons cette fois un peu plus dans les détails du send et du recv, puisqu'il s'agit de mettre en place son protocole, ses règles d'échange de données, en utilisant des paquets TCP.
Il s'agit également de la dernière partie de la première série grâce à laquelle nous savons désormais utiliser TCP en tant que client.
La seconde partie traitera toujours de TCP, mais du point de vue du serveur maintenant.

:fleche: http://bousk.developpez.com/cours/re...ace-protocole/

Salut,

petite proposition d'amélioration : montrer la mise en place de macro/commandes prépro pour avoir un code multiplateforme unique. Je suis sûr que ça pourrait intéresser les arpètes qui passeraient sur tes tuto.

Bonne continuation.

edit : my bad, j'ai dû lire trop vite ou faire l'impasse sur la partie C++

Salut,

tu veux dire exactement ce qui est fait dans la seule partie qui le nécessite jusque là ? :roll:
Sinon je vois pas où tu en attends plus.

Excellent cours très clair.
Celui là il faut que je me le garde. Je fais de temps en temps de la programmation réseau mais j'oublie régulièrement comment ça marche du coup je suis obliger de replonger dans mes archives.

Bonne initiative.

J'ai rarement l'occasion de faire de la programmation réseau, et cela fera une source de plus pour me remettre dans le bain.

Je trouve toutefois qu'il manque une explication du concept de socket.

Salut oodini,
à quelle explication de quel concept penses-tu ?
J'ai eu du mal à écrire la première partie qui est sensée introduire ça, et j'ai finalement opté pour le très simple paragraphe qui s'y trouve Un socket, qu'il soit TCP ou UDP, sera défini par un simple entier qui le représente et devra être passé aux fonctions qui l'utilisent. puisque c'est suffisant imo comme information. Le but étant d'apprendre à le manipuler et pas de faire des tirades philosophiques qui finalement n'apportaient rien de plus comme information. :)

Quelle est la sémantique d'un socket ?
Ça représente quoi ?

Pas besoin de faire un long laïus : deux ou trois phrases suffisent. Tu peux parler de connecteur de transmission, par exemple.

Inspire-toi du premier paragraphe de la page Wikipedia ! :)

Salut à tous,

de retour après quelques mois (été, vacances, écriture, boulot, ...)
Il est maintenant temps de passer de l'autre côté et commencer à travailler sur la partie serveur. La partie cliente étant suffisament avancée pour notre utilisation jusque là.
Il s'agit de la partie serveur faisant mirroir à la première partie cliente, donc seuls les concepts de connexion seront présentés : architecture très (et trop) simpliste d'un serveur, comment initialiser un socket pour être utilisé en tant que serveur, comment s'y connecter via l'ip et le port, ainsi que quelques explication pour retrouver les informations du client que l'on reçoit (IP et port).

:fleche: http://bousk.developpez.com/cours/re...-premiers-pas/

Merci beaucoup pour ce cours, c'est clair et précis !

Salut à tous,

avant de pouvoir écrire la suite du serveur, il convient de voir ce qu'est un thread, un mutex et comment les utiliser.
Cette partie ne se veut pas être un cours à part entière sur ces objets et n'est pas du tout exhaustive mais montre le nécessaire à leur utilisation pour la suite du cours.
Un paragraphe présente également la bibliothèque C++ rest sdk, le namespace pplx précédemment connu sous le nom de code Casablanca, mais ne sera finalement pas utilisé dans la suite du cours pour le moment.

:fleche: http://bousk.developpez.com/cours/multi-thread-mutex/

Bonjour,

Citation:

---

Envoyé par Bousk

avant de pouvoir écrire la suite du serveur, il convient de voir ce qu'est un thread, un mutex et comment les utiliser.

---

Citation:

---

Envoyé par Bousk

De manière générale, il est préférable de construire son application de manière à ce que le code soit synchronisé par construction. En effet, un mutex est un point de contention, utilisé pour que deux tâches ne puissent s'exécuter en parallèle. On verrouillera un mutex pour l'acquérir, les appels successifs ne pourront alors pas le verrouiller et devront attendre qu'il soit libéré. Il s'agit bel et bien d'une attente, donc de bloquer le thread en question.

---

Comme je te l'ai déjà signalé, tu présentes les mutex de manière erronée. Un mutex n'est pas fait pour synchroniser des tâches, mais pour éviter des accès concurrents à une "ressource" (une variable, un fichier, un socket, etc...). Il est possible de gérer la synchronisation de plusieurs tâches à l'aide de mutex, mais c'est loin d'être l'utilisation première ! C'est comme planter un clou avec un tournevis. On peut le faire, mais ce n'est pas le plus pratique :mouarf:

Un mutex est fait pour s'assurer qu'une ressource n'est utilisée que par une et une seule tâche en même temps. Et un bon mutex ne sert à rien 99,9% du temps :)

Mais hormis ce point, good tutorial :king:

Pour aller plus loin, peut-être que ça serait bien d'aborder la "vraie" manière de gérer de multiples connexions côté serveur, à savoir, utiliser les boucles d'événements basées sur epoll, kqueue ou IO Completion Ports. Pourquoi pas en utilisant une bibliothèque qui les abstrait comme libevent.

Bon c'est vraiment pour la partie la plus avancée du cours, mais ça permet justement de ne pas utiliser de threads ;).

Salut à tous,

il est temps que notre serveur passe la première vitesse et soit capable de réceptionner des données de ses clients et leur en envoyer.
Plusieurs modèles sont présentés et testés : multiplier les threads, l'utilisation de select, poll ou de sockets non bloquants.

:fleche: http://bousk.developpez.com/cours/re...ption-serveur/

Salut à tous,

dans la ligne directe de l'article précédent, voici un très court chapitre traitant du mode non bloquant cette fois chez le client.

:fleche: http://bousk.developpez.com/cours/re...-non-bloquant/

Salut à tous,

il s'agit d'un des derniers chapitres à propos du client TCP, dans lequel un client fonctionnel est implémenté en détail.
Retrouvez les propriétés souhaitées pour le client qui justifient cette implémentation, ainsi qu'un exemple d'utilisation dans du code utilisateur.

:fleche: http://bousk.developpez.com/cours/re...ecture-client/

Salut à tous,

Cet article présente la mise en place d'un miniserveur, destiné à tourner en parallèle du jeu, au sein du même exécutable, sur une machine cliente.
La partie la plus importante, et pourtant très simple, est l'évolution du code du chapitre précédent afin de garder une interface claire et connue pour pouvoir écrire et manipuler du code serveur.

:fleche: http://bousk.developpez.com/cours/re...-mini-serveur/

Salut à tous,

changeons un peu d'air afin de nous intéresser à l'utilisation d'UDP.
Ce premier chapitre introduit un peu de vocabulaire, résume les garanties d'UDP et ce qu'on peut attendre en comparaison de TCP et pourquoi il est utilisé.
Ensuite notre premier socket UDP et programme est mis en place avant de finir sur une explication des phénomènes de pertes et duplications inhérents à l'utilisation d'UDP et une première façon de les limiter.

:fleche: http://bousk.developpez.com/cours/re...-premiers-pas/

Salut à tous,

avant d'attaquer l'implémentation du protocole en soit, voici un chapitre présentant comment détecter qu'un identifiant est perdu ou dupliqué ainsi que comment gérer sa réinitialisation après avoir atteint la valeur maximale.

:fleche: http://bousk.developpez.com/cours/re...-identifiants/

Salut à tous,

vue la complexité d'un tel développement, il convient de tester que son code se comporte comme attendu.
Ce très court chapitre introduit donc une solution de tests, unitaires et autres, afin de vous initier à cette pratique.
Ces tests seront étoffés au fur et à mesure des articles et de l'élaborration du moteur réseau.
Je vous présente également le dépôt contenant les sources du moteur créé dans le cadre de l'écriture de ce cours et vous sensibilise à l'utilisation d'un tel outil.

:fleche: http://bousk.developpez.com/cours/re...n-place-tests/

Salut à tous,

une année entière s'est écoulée depuis le dernier chapitre 8O
L'écriture n'a pas été arrêtée mais fut très ralentie pendant 2018 par une surcharge professionnelle et personnelle.
2019 sera également chargée mais quelques chapitres devraient voir le jour.

Il est temps d'appréhender la création de son protocol par-dessus UDP.
Ce chapitre est l'approfondissement du chapitre 2 qui introduit la gestion des pertes et duplicatas de datagrammes.

:fleche: https://bousk.developpez.com/cours/r...eer-protocole/

Bonjour,

Je suis complètement largué dans le TD01, comment est-on supposé lancer un serveur ? (On a une fonction de connexion, mais où est celle de mise en écoute ?)

Edit : Je viens de regarder les fichiers sources de la correction et ...
J'ai l'impression d'avoir raté un chapitre, l'exercice commence par "Lancez ou compilez le TD 01. Un serveur se lancera sur le port de votre choix et créez un client capable de se connecter à celui-ci.". Je n'ai pas trouvé de lien vers un code source de base pour ce TD, juste le code source de la solution qui comprend aussi un exemple de client. Qu'ai-je manqué ?

Tu as une version compilée avec VS2015 dans Samples/Win10, il faut les redistributables VS2015 pour la lancer.
Les codes sources sont accessibles via le lien "Télécharger les codes sources du cours" tout en bas de l'article. Un lien a été ajouté plus haut pour plus de clarté.

Sinon tu peux la recompiler depuis les solutions, VS2013 & VS2015 sont proposées. Elles sont upgradables vers VS2017 sans soucis.
Il y a un problème avec les versions de Win10 plus récentes, il faut changer les tests #if _WIN32_WINNT == _WIN32_WINNT_WINBLUE en #if _WIN32_WINNT >= _WIN32_WINNT_WINBLUE dams Main.cpp et Clients_Sample/Sockets.hpp
L'article a été mis à jour avec ces corrections.

Salut à tous,

maintenant que nous avons vu les bases de la création d'un protocole, nous allons enfin itérer sur celle-ci.
Dans ce nouveau chapitre, apprenez comment découper à l'envoi et réunifier à la réception des messages trop gros pour être envoyés par un paquet seul.
Également comment optimiser l'envoi en envoyant plusieurs paquets par datagramme si ceux-ci sont suffisament petits.
Enfin, le chapitre se conclue par la création d'un protocole ordonné non fiable en utilisant UDP.

:fleche: https://bousk.developpez.com/cours/r...ifier-paquets/

Salut à tous,

après la création d'un protocole ordonné non fiable, apprenez maintenant à créer un protocole ordonné et fiable.
Ce nouveau chapitre est très similaire au précédent et présentera également une optimisation afin de ne pas perdre le contrôle sur la réception des paquets et la mémoire allouée à cette fin.

:fleche: https://bousk.developpez.com/cours/r...rdonne-fiable/

Salut à tous,

nous avons créé dans les chapitres précédents un protocole ordonné non fiable et un protocole ordonné et fiable, mais seul l'ordonné non fiable était utilisé dans le moteur.
Ce nouveau chapitre présente comment profiter de 2 protocoles ou plus dans votre application via l'introduction de canaux de communication utilisant l'unique socket et connexion dont nous disposons.

:fleche: https://bousk.developpez.com/cours/r...er-protocoles/

Salut à tous,

nous nous écartons légèrement du réseau à proprement parler pour parler de sérialisation.
Bien qu'essentielle dans l'envoi de données, ces chapitres peuvent également être utilisés indépendamment (système de sauvegarde, ...).
Nous commençons par les bases avec une sérialisation simple.

Bonne lecture !
:fleche: https://bousk.developpez.com/cours/serialisation-bases/

Bonjour

La sérialisation comme indiquée ne fonctionnera pas entre machine avec des architecture "little indian" / "big indian" différentes.
A préciser peut-être ?

As-tu lu l'article entier ? Pourquoi elle ne fonctionnerait pas ? :weird:
La première moitié de l'article parle et montre les problèmes d'endianness et indique comment les résoudre via des conversions.
Les implémentations suivantes utilisent ces conversions pour contrer ce problème.

Salut à tous,

après les bases de la sérialisation, passons à la vitesse supérieure et voyons comment optimiser cette sérialisation, en minimisant la taille du tampon nécessaire.
Dans ce chapitre, nous voyons comment sérialiser des valeurs sur des bits et non uniquement sur des octets (une valeur entière sur 7 ou 28 bits par exemple).
Mais aussi comment rendre ceci plus aisé en considérant les valeurs possibles plutôt que le nombre de bits nécessaire à les représenter.

Bonne lecture !
:fleche: https://bousk.developpez.com/cours/serialisation-bits/

Super cours, merci pour le partage.

Salut à tous,

troisième chapitre dédié à la sérialisation.
Dans celui-ci nous mettons en places un type optimisé pour transférer des entiers sur intervalle, des nombres à virgule fixe pour remplacer les nombres à virgule flottante et des énumérations.
Ce chapitre utilise énormément la métaprogrammation pour y parvenir et nécessite le passage au C++17.

Bonne lecture !
:fleche: https://bousk.developpez.com/cours/s...ation-avancee/

Bonjour,
merci pour ce cour bien utile pour poser les bases.

Juste un petit problème rencontré lors de la compilation avec Visual Studio 2019 sur Windows 10.

Le projet TP01 est ok mais à partir du TP02 il faut remplacer:

Code:

---

#if _WIN32_WINNT == _WIN32_WINNT_WINBLUE

---

par

Code:

---

#if _WIN32_WINNT >= _WIN32_WINNT_WINBLUE

---

Ah merci, j'étais justement en train de le faire, et j'avais cette erreur.

Bien vu, j'avais fixé le TP01 mais n'ai pas pensé aux suivants...
J'essayerai de repasser dessus.

Salut à tous,

nous revenons à notre protocole UDP en ajoutant une couche importante pour toute application : la gestion de connexions.
Dans ce chapitre, vous verrez comment mettre en place un système de connexions qui permet de savoir quand une machine essaye de nous joindre, d'accepter ou refuser cette connexion puis de terminer la connexion en notifiant les intéressées à chaque étape.
Un timeout fait également son apparition pour gérer la perte de connexion ou l'absence de réponse à une demande de connexion, afin de ne pas bloquer le moteur et l'application dans un état non souhaité.

Bonne lecture !
:fleche: https://bousk.developpez.com/cours/r...on-connexions/

Hello,
je viens de revoir toutes les archives des TP TCP et la compilation devrait être correcte sur vs2019. #if _WIN32_WINNT == _WIN32_WINNT_WINBLUE a normalement été remplacé de partout par #if _WIN32_WINNT >= _WIN32_WINNT_WINBLUE. N'hésitez pas à me faire savoir s'il reste une coquille quelque part.