Cours programmation réseau en C++

TCP - Un premier serveur : miniserveur

Bousk

Voyons une implémentation d'un premier miniserveur et les évolutions de code nécessaires pour y parvenir.

Commentez

- Titre : Cours programmation réseau en C++

- Auteur : Bousk

- Parution : 22 août 2017

- Mise à jour : 19 août 2017

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2017 Cyrille (Bousk) Bousquet. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. De quel serveur s'agit-il ?

- II. Représentation des clients sur le serveur

- II-A. Initialisation depuis le serveur

- III. Interface du serveur

- III-A. Pourquoi une fonction update ?

- IV. Implémentation de la classe Server

- IV-A. Liste de clients connectés

- IV-B. bool start(unsigned short _port);

- IV-B-1. Adresse réutilisable ?

- IV-B-1-a. Unix - int setsockopt(int sckt, int level, int optname, const void* optval, socklen_t optlen);

- IV-B-1-b. Windows - int setsockopt(SOCKET sckt, int level, int optname, const char* optval, int optlen);

- IV-B-1-b-1. Doit-on définir un socket comme réutilisable sur Windows ?

- IV-C. void stop();

- IV-D. void update();

- IV-E. std::unique_ptr<Messages::Base> poll();

- V. Qui est l'expéditeur de ce message ?

- V-A. Identifiant de client

- V-A-1. uint64_t id() const ;

- V-B. Mise à jour des Messages

- V-C. Coordonnées du client

- V-C-1. Coordonnées du serveur

- V-C-1-a. Récupérer le port d'une adresse

- V-D. Ajouter les coordonnées dans le message pour le serveur

- V-E. Comment joindre un client ?

- V-E-1. Mise à jour de la collection de clients

- V-E-2. Envoyer des données à un client spécifique

- VI. Code final du serveur

- VI-A. Server.hpp

- VI-B. Server.cpp

- VI-C. Exemple d'utilisation

- VI-D. Code du client mis à jour

- VI-D-1. Client.hpp

- VI-D-2. Client.cpp

I - De quel serveur s'agit-il ?

Il s'agira d'un « miniserveur » : un serveur destiné à gérer un faible nombre de connexions, de l'ordre de la dizaine ou centaine - mais cela peut varier selon le matériel et la puissance possédés.

Le serveur tournera sur une machine cliente, un joueur fera office de serveur, et ne sera pas exécuté sur une machine distante dédiée. Il devra donc pouvoir tourner en parallèle du programme principal et ne devra pas bloquer celui-ci. Il s'agit du cas où un joueur fait office d'hôte.

Nous utiliserons le mode non bloquant pour y parvenir.

Si le besoin devient de déplacer le programme serveur sur sa propre machine dédiée, aucun changement ne sera nécessaire - tant que son but (accueillir une centaine de joueurs) ne change pas. Vous devriez être capable d'extraire le code spécifique au serveur dans un programme à part et supprimer l'affichage (par exemple) inutile dans ce cas.

Si le serveur devient plus gros et doit accueillir une population plus importante, l'architecture mise en place dans ce chapitre ne sera pas adaptée.

II - Représentation des clients sur le serveur

Quelle est la différence entre un client - la machine cliente - tel que nous l'avons vu et mis en place dans le chapitre précédent et un client - la représentation locale de la machine cliente sur un serveur - ? Quasiment aucune !

Souvenez-vous que dans le chapitre traitant de l'envoi et réception des données depuis le serveur, nous faisons appel aux mêmes fonctions recv et send pour la réception et l'envoi. Donc l'échange de données est identique.

La seule différence est que notre client serveur (appelons ainsi le socket qui représente un client sur le serveur) ne va pas créer la connexion entre le client et le serveur, mais plutôt accepter la connexion entrante sur le serveur, via un appel à accept du serveur (voir chapitre 4) et non socket pour créer le socket suivi de connect (voir chapitre 1). C'est donc uniquement l'initialisation du socket qui diffère.

Nous utiliserons donc logiquement la même classe Client, en modifiant comme nécessaire son fonctionnement interne et son interface afin qu'on puisse l'utiliser indifféremment comme client - comme code client sur une machine cliente - et client serveur - représentation du client sur une machine serveur.

II-A - Initialisation depuis le serveur

L'initialisation sera en fait bien plus simple : accept retourne directement un socket valide qu'il suffira donc de passer à notre classe Client afin qu'elle l'utilise.

Ajoutons donc simplement une fonction init à cette fin que l'on implémentera ainsi :

1. bool ClientImpl::init(SOCKET&& sckt)

2. {

3. assert(sckt != INVALID_SOCKET);

4. if (sckt == INVALID_SOCKET)

5. return false;

7. assert(mState == State::Disconnected);

8. assert(mSocket == INVALID_SOCKET);

9. if (mSocket != INVALID_SOCKET)

10. disconnect();

12. mSocket = sckt;

13. if (!SetNonBlocking(mSocket))

14. {

15. disconnect();

16. return false;

17. }

18. mSendingHandler.init(mSocket);

19. mReceivingHandler.init(mSocket);

20. mState = State::Connected;

21. return true;

22. }

Puisque notre socket ainsi initialisé est déjà connecté, il suffit de le passer en mode non bloquant uniquement - c'est le mode nécessaire à l'utilisation de notre classe Client suite au chapitre précédent. Si l'initialisation du mode non bloquant est réussie, alors on passe notre client directement en état connecté et initialisons la réception et l'envoi de données, sinon on déconnecte le client.

Le socket en paramètre pourrait être passé par copie, mais le passer par déplacement permet de renforcer l'idée que la classe prend possession du socket lors de l'appel à cette fonction.

III - Interface du serveur

Il est maintenant temps d'avoir une classe Server à utiliser dans un programme principal.

L'utilisation retenue sera la même que pour notre classe Client : initialisation et extraction des messages via appel à poll.

Notre interface devrait donc ressembler à :

1. class Server

2. {

3. public:

4. Server();

5. Server(const Server&) = delete;

6. Server& operator=(const Server&) = delete;

7. Server(Server&&);

8. Server& operator=(Server&&);

9. ~Server();

11. bool start(unsigned short _port);

12. void stop();

13. void update();

14. std::unique_ptr<Messages::Base> poll();

16. private:

17. std::unique_ptr<ServerImpl> mImpl;

18. };

Tout comme notre Client, un Server sera déplaçable, mais non copiable. Le pattern pimpl sera réutilisé puisqu'il est toujours un bon candidat pour cet exercice.

Pour le démarrer, nous utiliserons la méthode start en passant en paramètre le port souhaité. La fonction stop servira à arrêter le serveur et déconnecter tous les clients.

update servira à mettre à jour le serveur, l'état de chaque client connecté et enfin poll retournera le message suivant à traiter.

Le serveur sera accessible uniquement depuis une connexion IPv4 pour le moment. Le port demandé sera initialisé avec un socket IPv4.

L'utilisation d'IPv6 sera étudiée lors d'un prochain chapitre dans lequel le code Client et Server sera mis à jour.

III-A - Pourquoi une fonction update ?

Notre serveur aura une liste de clients connectés. Que se passerait-il si nous n'avions qu'une fonction poll pour récupérer les données des clients ? Le serveur itérerait sur sa collection de clients, et retournerait le premier message complet du premier client.

Avec une simple collection type vector, l'itération serait toujours dans le même ordre, donc notre serveur retournerait les messages des premiers clients en priorité. Potentiellement le dernier client arrivé n'aurait jamais aucun message traité par le serveur.

Avec l'ajout d'une fonction update, on s'assure de gérer tous les clients, puis de mettre en file les messages reçus lors de ce traitement. Ainsi, sans être parfaitement égaux dans la file, la priorité des premiers clients connectés est moindre sur les derniers. Une autre astuce est de limiter à un message par client à chaque appel à update par exemple.

Ceci est préférable à avoir une collection plus intelligente qui garderait en mémoire où l'itération s'est arrêtée la dernière fois afin de traiter le client suivant : si vous avez un grand nombre de clients, ou particulièrement rapides, vous pourriez recevoir un nouveau message du premier avant d'avoir traité le dernier, l'appel à poll retournerait alors toujours un message valide et vous ne sortiriez jamais de la boucle d'appel à poll dans votre programme principal.

On aura un problème similaire sur l'acceptation de nouveaux clients : si notre serveur se fait spammer de connexions, il passera son temps à accepter des clients sans traiter les existants. De la même manière, nous pouvons limiter, par exemple, à dix nouveaux clients par appel à update.

L'établissement d'une connexion est un processus réputé relativement lent, donc retarder le traitement des connexions entrantes de quelques millisecondes est acceptable et n'entraînera pas la grogne des utilisateurs. Par contre une fois connectés, ils sont en général plutôt impatients de pouvoir communiquer avec le serveur.

IV - Implémentation de la classe Server

IV-A - Liste de clients connectés

Les clients connectés seront sauvegardés dans une collection type std::vector pour le moment. Dans les codes suivants, mClients est défini comme std::vector<Client> mClients; où Client est la classe Client introduite dans le chapitre précédent.

IV-B - bool start(unsigned short _port);

L'appel à start déclenchera l'initialisation du serveur telle qu'on la connaît depuis le chapitre 5.

Son implémentation sera donc juste une adaptation de ce que l'on avait alors vu, en ajoutant l'étape pour rendre le socket non bloquant :

1. bool ServerImpl::start(unsigned short _port)

2. {

3. assert(mSocket == INVALID_SOCKET);

4. if (mSocket != INVALID_SOCKET)

5. stop();

6. mSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

7. if (mSocket == INVALID_SOCKET)

8. return false;

10. if (!SetReuseAddr(mSocket) || !SetNonBlocking(mSocket))

11. {

12. stop();

13. return false;

14. }

16. sockaddr_in addr;

17. addr.sin_addr.s_addr = INADDR_ANY;

18. addr.sin_port = htons(_port);

19. addr.sin_family = AF_INET;

20. if (bind(mSocket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0)

21. {

22. stop();

23. return false;

24. }

25. if (listen(mSocket, SOMAXCONN) != 0)

26. {

27. stop();

28. return false;

29. }

30. return true;

31. }

IV-B-1 - Adresse réutilisable ?

Un serveur utilisera généralement un port spécifique sur l'ensemble des adresses disponibles. Il n'est pas rare également que la machine serveur ait des mécanismes au niveau du système pour relancer automatiquement le programme en cas de problème, erreur ou crash, type cron sur Unix ou les services Windows.

En cas d'arrêt intempestif du programme serveur, à fortiori si des clients étaient toujours connectés, il est fort à parier que des échanges étaient toujours en cours. Afin de terminer proprement les connexions, le socket TCP sera maintenu par le système dans un état nommé TIME_WAIT. Le socket dans cet état attendra que les derniers échanges se terminent afin que sa connexion soit terminée correctement du point de vue du protocole TCP, ou qu'il arrive à expiration (timeout), généralement après deux minutes.

Si l'on essaye de rouvrir un socket sur ce port, ce qui arrive généralement plus rapidement que les deux minutes d'expiration, à fortiori si c'est le système qui le gère, le système va retourner une erreur EADDRINUSE ou EACCESS, respectivement adresse déjà utilisée ou erreur d'accès, tant que notre socket fantôme est dans cet état, empêchant un nouveau socket d'être créé à cette adresse et utilisant le port souhaité.

Pour contrer ça, il existe le flag SO_REUSEADDR qui permet entre autres d'indiquer au système qu'il est autorisé à réutiliser une adresse et un port d'un socket dans l'état TIME_WAIT.

Pour des informations plus en détail et spécificités de chaque plateforme, voici un excellent post sur StackOverflow.

IV-B-1-a - Unix - int setsockopt(int sckt, int level, int optname, const void* optval, socklen_t optlen);

Permet d'effectuer une opération sur un socket. Il s'agit de l'inverse de getsockopt que nous avions utilisé pour récupérer l'erreur spécifique d'un socket dans le chapitre 5.

- sckt est le socket sur lequel agir.

- level est le niveau relatif à l'opération que nous voulons effectuer. Pour un socket, il s'agira toujours de SOL_SOCKET.

- optname est le nom de l'opération à effectuer. Dans notre cas présent SO_REUSEADDR.

- optval est un pointeur vers la valeur à appliquer à l'opération.

- optlen la taille de la valeur pointée par optval.

1. int optval = 1;

2. setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

Retourne -1 en cas d'échec, 0 sinon.

IV-B-1-b - Windows - int setsockopt(SOCKET sckt, int level, int optname, const char* optval, int optlen);

La signature change à peine, optval est passé en tant que const char* plutôt que const void* et optlen est un int et non un socklen_t.

Ce qui permettrait d'écrire ceci avec notre code actuel pour avoir un appel portable :

1. int optval = 1;

2. setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&optval), sizeof(optval));

Retourne SOCKET_ERROR en cas d'erreur, 0 sinon.

IV-B-1-b-1 - Doit-on définir un socket comme réutilisable sur Windows ?

Cette option n'a que peu d'intérêt sur Windows, dû à l'implémentation de celle-ci par le système.

En effet, Windows définit SO_REUSEADDR comme permettant au socket de s'associer (bind) de force à un port déjà ouvert par un autre socket. Un programme peut donc usurper l'utilisation d'un port sur une adresse locale, ou toutes les adresses locales. Puis on tombe dans un indéterminisme des plus complets : vous avez deux sockets qui utilisent le même port et travaillent sur la même adresse, les données vont aller à l'un ou l'autre sans aucune garantie et aléatoirement - mais toujours à l'un ou l'autre - sans que vous puissiez rien y faire.

L'aspect usurpation de socket a depuis été rectifié en ajoutant l'option SO_EXCLUSIVEADDRUSE, qui permet d'empêcher toute autre ouverture du même port. Rien qui ne nous intéresse dans notre cas pour rouvrir un socket sur un port qui serait dans l'état TIME_WAIT suite au crash de notre serveur. Rien d'utile à notre niveau donc.

Lire les sujets sur la MSDN à ce sujet ici et ici.

IV-C - void stop();

stop aura pour effet de déconnecter les clients existants et libérer le socket du serveur.

1. void ServerImpl::stop()

2. {

3. for (auto& client : mClients)

4. client.disconnect();

5. mClients.clear();

6. if (mSocket != INVALID_SOCKET)

7. CloseSocket(mSocket);

8. mSocket = INVALID_SOCKET;

9. }

IV-D - void update();

Notre fonction aura deux objectifs : accepter les nouvelles connexions et gérer les clients existants.

Afin de limiter l'inégalité des clients face à leur ordre de connexion, nous limiterons la réception des messages à un par client.

De même, afin de limiter l'éventuel spam de connexions et continuer de traiter les clients déjà connectés, nous limiterons à dix les nouveaux clients par appel à update.

Il suffit de dérouler cet algorithme pour obtenir une implémentation :

1. void ServerImpl::update()

2. {

3. if (mSocket == INVALID_SOCKET)

4. return;

6. //!< accept jusqu'à 10 nouveaux clients

7. for (int accepted = 0; accepted < 10; ++accepted)

8. {

9. sockaddr_in addr = { 0 };

10. socklen_t addrlen = sizeof(addr);

11. SOCKET newClientSocket = accept(mSocket, reinterpret_cast<sockaddr*>(&addr), &addrlen);

12. if (newClientSocket == INVALID_SOCKET)

13. break;

14. Client newClient;

15. if (newClient.init(std::move(newClientSocket)))

16. {

17. auto message = std::make_unique<Messages::Connection>(Messages::Connection::Result::Success);

18. mMessages.push_back(std::move(message));

19. mClients.push_back(std::move(newClient));

20. }

21. }

23. //!< mise à jour des clients connectés

24. //!< réceptionne au plus 1 message par client

25. //!< supprime de la liste les clients déconnectés

26. for (auto itClient = mClients.begin(); itClient != mClients.end(); )

27. {

28. auto& client = *itClient;

29. auto msg = client.poll();

30. if (msg)

31. {

32. if (msg->is<Messages::Disconnection>())

33. itClient = mClients.erase(itClient);

34. else

35. ++itClient;

36. mMessages.push_back(std::move(msg));

37. }

38. else

39. ++itClient;

40. }

41. }

N'oubliez pas de générer un Message::Connection lorsqu'un nouveau client est accepté par le serveur pour que l'application puisse avoir l'information.

IV-E - std::unique_ptr<Messages::Base> poll();

Ici poll sera des plus simples à implémenter. Puisque update se charge de mettre en file les messages, poll n'aura qu'à les dépiler afin de les retourner à l'application.

1. std::unique_ptr<Messages::Base> ServerImpl::poll()

2. {

3. if (mMessages.empty())

4. return nullptr;

6. auto msg = std::move(mMessages.front());

7. mMessages.pop_front();

8. return msg;

9. }

Dans cette implémentation, les fonctions update et poll sont supposées appelées depuis le même thread.

Si vous souhaitez appeler update et poll depuis différents threads, il vous faudra synchroniser l'accès à mMessages à l'aide de mutex par exemple.

V - Qui est l'expéditeur de ce message ?

Vous vous serez sans doute déjà fait la réflexion : j'extrais un message via poll, mais je n'ai aucune idée de qui l'a envoyé !

En effet, notre hiérarchie de messages était utilisée jusque-là par le client uniquement, qui ne pouvait recevoir un message que du serveur auquel il était connecté. Mais notre serveur peut recevoir des messages de plusieurs clients, il faut donc ajouter quelques informations supplémentaires quant à l'origine du message reçu.

V-A - Identifiant de client

L'idée est d'ajouter un identifiant unique pour chaque client.

La bonne nouvelle c'est que nous avons déjà un tel identifiant à disposition, généré par le système et assuré unique pour chaque connexion : le socket !

Sur Unix, il s'agit d'un int, généralement ayant une valeur plutôt faible qui plus est.

Sur Windows c'est un type plus opaque, un entier non signé, mais qui sur toutes les versions jusque-là se retrouve être un typedef sur un entier non signé 64 bits ou plus petit.

Pour couvrir ces deux cas, notre identifiant sera un uint64_t.

V-A-1 - uint64_t id() const ;

Ajoutons donc cette très simple fonction à notre interface Client :

class ClientImpl
{
…
uint64_t id() const { return static_cast<uint64_t>(mSocket); }
…
};

uint64_t Client::id() const { return mImpl ? mImpl->id() : (uint64_t)(-1); }

Notez que tous les clients non initialisés partageront l'identifiant -1. Heureusement un client n'est pas censé être utilisé non initialisé très longtemps vous ne devrez donc avoir aucun problème à cause de cela.

Si un client est déplacé, son identifiant sera également la valeur non initialisée suite au déplacement. Mais ici encore, vous ne devriez pas avoir à traiter des clients déplacés très longtemps. Une fois déplacé, vous aurez vite fait de vous en débarrasser et le libérer.

V-B - Mise à jour des Messages

Il faut maintenant mettre à jour nos Messages pour ajouter cet identifiant.

Pas besoin de chercher compliqué pour le moment, et ajoutons juste un champ à la structure de Base uint64_t idFrom;.

1. namespace Network

2. {

3. namespace Messages

4. {

5. class Base

6. {

7. public:

8. template<class M>

9. bool is() const { return mType == M::StaticType; }

10. template<class M>

11. const M* as() const { return static_cast<const M*>(this); }

13. uint64_t idFrom;

15. protected:

16. enum class Type {

17. Connection,

18. Disconnection,

19. UserData,

20. };

21. Base(Type type)

22. : mType(type)

23. {}

24. private:

25. Type mType;

26. };

27. }

28. }

Le mettre dans la portée publique simplifie les modifications à apporter au reste de la bibliothèque. Si vous préférez l'inclure dans le constructeur et le mettre en privé, il vous faudra modifier tous les constructeurs et leur appel, puis penser à mettre un accesseur public.

Ensuite modifiez les générations de messages afin d'ajouter l'identifiant du client correspondant à chaque fois où nécessaire.

Ou bien vous pouvez l'ajouter à un seul emplacement : dans le poll du serveur. Après tout il n'est pas vraiment utile d'ajouter l'identifiant du client si on utilise directement le client : le message vient forcément du serveur auquel il est connecté.

V-C - Coordonnées du client

Parmi les informations utiles que nous n'avons pas encore retrouvées, se trouvent l'adresse IP et le port du client.

Cette information est récupérée lors de l'appel à accept, mais directement oubliée puisque nous n'initialisons le client qu'avec le socket.

Mettons donc à jour notre fonction init pour également passer l'information d'adresse du client :

1. class ClientImpl

2. {

3. …

4. bool init(SOCKET&& sckt, const sockaddr_in& addr);

5. …

6. const sockaddr_in& destinationAddress() const { return mAddress; }

7. …

8. sockaddr_in mAddress{ 0 };

9. };

10. bool ClientImpl::init(SOCKET&& sckt, const sockaddr_in& addr)

11. {

12. assert(sckt != INVALID_SOCKET);

13. if (sckt == INVALID_SOCKET)

14. return false;

16. mSocket = sckt;

17. mAddress = addr;

18. if (!SetNonBlocking(mSocket))

19. {

20. disconnect();

21. return false;

22. }

23. onConnected();

24. return true;

25. }

N'oubliez pas de réinitialiser l'adresse dans la fonction disconnect avec un memset(&mAddress, 0, sizeof(mAddress));.

V-C-1 - Coordonnées du serveur

Afin de garder une utilisation cohérente lorsque notre classe Client est utilisée en tant que client de connexion à un serveur, utilisons cette variable mAddress pour sauvegarder les informations du serveur auquel le client est connecté. destinationAddress() retournera ainsi toujours l'adresse de destination du client : du client derrière le client serveur dans le cadre d'un serveur, et du serveur auquel est connecté le client dans le cadre d'un client.

Comme il s'agit de l'adresse à laquelle le client se connecte, le code qui génère cette information se retrouvera dans le ConnectionHandler :

1. class ConnectionHandler

2. {

3. …

4. const sockaddr_in& getConnectedAddress() const { return mConnectedAddress; }

5. …

6. sockaddr_in mConnectedAddress;

7. };

8. bool ConnectionHandler::connect(SOCKET sckt, const std::string& address, unsigned short port)

9. {

10. assert(sckt != INVALID_SOCKET);

11. mAddress = address;

12. mPort = port;

13. mFd.fd = sckt;

14. mFd.events = POLLOUT;

15. inet_pton(AF_INET, mAddress.c_str(), &mConnectedAddress.sin_addr.s_addr);

16. mConnectedAddress.sin_family = AF_INET;

17. mConnectedAddress.sin_port = htons(mPort);

18. if (::connect(sckt, (const sockaddr*)&mConnectedAddress, sizeof(mConnectedAddress)) != 0)

19. {

20. int err = Errors::Get();

21. if (err != Errors::INPROGRESS && err != Errors::WOULDBLOCK)

22. return false;

23. }

24. return true;

25. }

Dans connect, nous avons juste remplacé le sockaddr_in server auparavant local par la variable membre mConnectedAddress.

L'accesseur est présent pour pouvoir initialiser ClientImpl::mAddress lorsque la connexion est réussie. J'opte pour factoriser les initialisations qui suivent une connexion réussie, que ce soit depuis init ou le gestionnaire de connexion :

1. bool ClientImpl::init(SOCKET&& sckt, const sockaddr_in& addr)

2. {

3. assert(sckt != INVALID_SOCKET);

4. if (sckt == INVALID_SOCKET)

5. return false;

7. mSocket = sckt;

8. if (!SetNonBlocking(mSocket))

9. {

10. disconnect();

11. return false;

12. }

13. onConnected(addr);

14. return true;

15. }

17. std::unique_ptr<Messages::Base> ClientImpl::poll()

18. {

19. switch (mState)

20. {

21. case State::Connecting:

22. {

23. auto msg = mConnectionHandler.poll();

24. if (msg)

25. {

26. if (msg->result == Messages::Connection::Result::Success)

27. {

28. onConnected(mConnectionHandler.getConnectedAddress());

29. }

30. else

31. {

32. disconnect();

33. }

34. }

35. return msg;

36. } break;

37. …

38. }

39. }

41. void ClientImpl::onConnected(const sockaddr_in& addr)

42. {

43. mAddress = addr;

44. mSendingHandler.init(mSocket);

45. mReceivingHandler.init(mSocket);

46. mState = State::Connected;

47. }

V-C-1-a - Récupérer le port d'une adresse

Nous avons déjà une fonction GetAddress qui retourne l'adresse IP depuis une structure sockaddr_in.

Voici une fonction pour récupérer le port depuis une telle structure, que vous aurez facilement devinée puisqu'elle est le miroir de l'initialisation du sockaddr_in pour l'appel à connect :

1. unsigned short GetPort(const sockaddr_in& addr)

2. {

3. return ntohs(addr.sin_port);

4. }

V-D - Ajouter les coordonnées dans le message pour le serveur

Dans les précédents chapitres, nous affichions toujours les informations de connexion du client sur le serveur à chaque réception de message.

Avec l'identifiant seul, il faudrait ajouter une interface pour récupérer un client ou ses informations à partir de l'identifiant introduit plus haut. Ce qui n'est pas très élégant et source de problème si notre code n'est plus monothreadé.

Au lieu de modifier l'interface du serveur, ajoutons cette information à nos messages, tout comme nous avons déjà ajouté l'identifiant :

1. class Base

2. {

3. …

4. sockaddr_in from;

5. …

6. };

Tout comme pour idFrom, il sera dans la portée publique et utilisée uniquement dans le cadre d'un serveur. Ce sera le serveur qui mettra à jour ce champ lors de la réception de données d'un client :

1. for (auto itClient = mClients.begin(); itClient != mClients.end(); )

2. {

3. auto& client = *itClient;

4. auto msg = client.poll();

5. if (msg)

6. {

7. msg->from = client.destinationAddress();

8. msg->idFrom = client.id();

9. if (msg->is<Messages::Disconnection>())

10. {

11. itClient = mClients.erase(itClient);

12. }

13. else

14. ++itClient;

15. mMessages.push_back(std::move(msg));

16. }

17. else

18. ++itClient;

19. }

V-E - Comment joindre un client ?

Notre serveur est capable de réceptionner les données de nos clients, mais pas encore de leur envoyer quoi que ce soit.

Mais nous avons désormais un identifiant pour nos clients.

V-E-1 - Mise à jour de la collection de clients

Puisque nous avons un identifiant unique et allons être amenés à retrouver un client dans notre collection, le seul vector est désormais remplacé par une map. Il sera ainsi plus simple de retrouver un client par son identifiant.

Désormais la définition de mClients est std::map<uint64_t, Client> mClients;. Le code à jour des parties implémentées plus haut est disponible en fin de chapitre.

V-E-2 - Envoyer des données à un client spécifique

Ajoutons donc deux méthodes pour envoyer des données à nos clients : l'une d'elles pour envoyer des données à un client précis, selon son identifiant, l'autre pour envoyer une même donnée à tous nos clients connectés - une opération toujours pratique dans le cadre d'un serveur :

1. bool sendTo(uint64_t clientid, const unsigned char* data, unsigned int len);

2. bool sendToAll(const unsigned char* data, unsigned int len);

4. bool ServerImpl::sendTo(uint64_t clientid, const unsigned char* data, unsigned int len)

5. {

6. auto itClient = mClients.find(clientid);

7. return itClient != mClients.end() && itClient->second.send(data, len);

8. }

9. bool ServerImpl::sendToAll(const unsigned char* data, unsigned int len)

10. {

11. bool ret = true;

12. for (auto& client : mClients)

13. ret &= client.second.send(data, len);

14. return ret;

15. }

sendTo sera utilisé pour envoyer des données à un client spécifique selon son identifiant et retournera true ou false selon que les données ont été mises en file d'envois avec succès ou non.

sendToAll tentera de mettre en file d'envois un même ensemble de données à tous les clients connus du serveur. Si la valeur de retour vaut true, tous les clients connus au moment de l'appel ont ces données en file d'envois. Sinon, au moins un client n'a pas pu les mettre en file et ne les recevra donc jamais.

Ici nous n'aurons aucune information sur quel(s) client(s) ne recevra(ont) pas les données en question. Si cette information vous importe, vous pourrez par exemple retourner un vector d'identifiants des clients qui ont échoué.

En pratique, puisque nous sommes en TCP, il n'y a aucune raison que les données ne soient pas mises en file d'envois, et donc reçues du moment que le client reste connecté assez longtemps pour les recevoir. En fait l'unique raison est que l'appel à notre Client::send retourne false, ce qui peut actuellement arriver pour deux raisons :

- le client n'est pas ou plus implémenté, après un déplacement par exemple et auquel cas ce client ne devrait plus être dans notre liste et sera certainement purgé prochainement ;

- SendingHandler::send retourne false, ce qui dans notre implémentation actuelle n'est possible que si la taille des données est trop élevée, et échouera donc pour tous les clients.

Vous aurez remarqué l'utilisation de mClients. Ces fonctions doivent donc être appelées sur le même thread que update.

Sinon, il vous faudra synchroniser mClients à l'aide d'un mutex par exemple.

VI - Code final du serveur

Nous avons maintenant un serveur fonctionnel prêt à accueillir nos utilisateurs.

VI-A - Server.hpp

TCP/Server.hpp

1. #pragma once

3. #include <memory>

5. namespace Network

6. {

7. namespace Messages {

8. class Base;

9. }

10. namespace TCP

11. {

12. class ServerImpl;

13. class Server

14. {

15. public:

16. Server();

17. Server(const Server&) = delete;

18. Server& operator=(const Server&) = delete;

19. Server(Server&&);

20. Server& operator=(Server&&);

21. ~Server();

23. bool start(unsigned short _port);

24. void stop();

25. void update();

26. bool sendTo(uint64_t clientid, const unsigned char* data, unsigned int len);

27. bool sendToAll(const unsigned char* data, unsigned int len);

28. std::unique_ptr<Messages::Base> poll();

30. private:

31. std::unique_ptr<ServerImpl> mImpl;

32. };

33. }

34. }

VI-B - Server.cpp

TCP/Server.cpp

1. #include "Server.hpp"

3. #include "Sockets.hpp"

4. #include "TCP/Client.hpp"

5. #include "Messages.hpp"

7. #include <map>

8. #include <list>

9. #include <cassert>

11. namespace Network

12. {

13. namespace TCP

14. {

15. class ServerImpl

16. {

17. public:

18. ServerImpl() = default;

19. ~ServerImpl();

21. bool start(unsigned short _port);

22. void stop();

23. void update();

24. bool sendTo(uint64_t clientid, const unsigned char* data, unsigned int len);

25. bool sendToAll(const unsigned char* data, unsigned int len);

26. std::unique_ptr<Messages::Base> poll();

28. private:

29. std::map<uint64_t, Client> mClients;

30. std::list<std::unique_ptr<Messages::Base>> mMessages;

31. SOCKET mSocket{ INVALID_SOCKET };

32. };

33. ServerImpl::~ServerImpl()

34. {

35. stop();

36. }

38. bool ServerImpl::start(unsigned short _port)

39. {

40. assert(mSocket == INVALID_SOCKET);

41. if (mSocket != INVALID_SOCKET)

42. stop();

43. mSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

44. if (mSocket == INVALID_SOCKET)

45. return false;

47. if (!SetReuseAddr(mSocket) || !SetNonBlocking(mSocket))

48. {

49. stop();

50. return false;

51. }

53. sockaddr_in addr;

54. addr.sin_addr.s_addr = INADDR_ANY;

55. addr.sin_port = htons(_port);

56. addr.sin_family = AF_INET;

57. if (bind(mSocket, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) != 0)

58. {

59. stop();

60. return false;

61. }

62. if (listen(mSocket, SOMAXCONN) != 0)

63. {

64. stop();

65. return false;

66. }

67. return true;

68. }

69. void ServerImpl::stop()

70. {

71. for (auto& client : mClients)

72. client.second.disconnect();

73. mClients.clear();

74. if (mSocket != INVALID_SOCKET)

75. CloseSocket(mSocket);

76. mSocket = INVALID_SOCKET;

77. }

78. void ServerImpl::update()

79. {

80. if (mSocket == INVALID_SOCKET)

81. return;

83. //!< accept jusqu'à 10 nouveaux clients

84. for (int accepted = 0; accepted < 10; ++accepted)

85. {

86. sockaddr_in addr = { 0 };

87. socklen_t addrlen = sizeof(addr);

88. SOCKET newClientSocket = accept(mSocket, reinterpret_cast<sockaddr*>(&addr), &addrlen);

89. if (newClientSocket == INVALID_SOCKET)

90. break;

91. Client newClient;

92. if (newClient.init(std::move(newClientSocket), addr))

93. {

94. auto message = std::make_unique<Messages::Connection>(Messages::Connection::Result::Success);

95. message->idFrom = newClient.id();

96. message->from = newClient.destinationAddress();

97. mMessages.push_back(std::move(message));

98. mClients[newClient.id()] = std::move(newClient);

99. }

100. }

102. //!< mise à jour des clients connectés

103. //!< réceptionne au plus 1 message par client

104. //!< supprime de la liste les clients déconnectés

105. for (auto itClient = mClients.begin(); itClient != mClients.end(); )

106. {

107. auto& client = itClient->second;

108. auto msg = client.poll();

109. if (msg)

110. {

111. msg->from = itClient->second.destinationAddress();

112. msg->idFrom = itClient->second.id();

113. if (msg->is<Messages::Disconnection>())

114. {

115. itClient = mClients.erase(itClient);

116. }

117. else

118. ++itClient;

119. mMessages.push_back(std::move(msg));

120. }

121. else

122. ++itClient;

123. }

124. }

125. bool ServerImpl::sendTo(uint64_t clientid, const unsigned char* data, unsigned int len)

126. {

127. auto itClient = mClients.find(clientid);

128. return itClient != mClients.end() && itClient->second.send(data, len);

129. }

130. bool ServerImpl::sendToAll(const unsigned char* data, unsigned int len)

131. {

132. bool ret = true;

133. for (auto& client : mClients)

134. ret &= client.second.send(data, len);

135. return ret;

136. }

137. std::unique_ptr<Messages::Base> ServerImpl::poll()

138. {

139. if (mMessages.empty())

140. return nullptr;

142. auto msg = std::move(mMessages.front());

143. mMessages.pop_front();

144. return msg;

145. }

146. ////////////////////////////////////////////////////////////////////////////////////

147. ////////////////////////////////////////////////////////////////////////////////////

148. ////////////////////////////////////////////////////////////////////////////////////

149. ////////////////////////////////////////////////////////////////////////////////////

150. ////////////////////////////////////////////////////////////////////////////////////

151. Server::Server() {}

152. Server::~Server() {}

153. Server::Server(Server&& other)

154. : mImpl(std::move(other.mImpl))

155. {}

156. Server& Server::operator=(Server&& other)

157. {

158. mImpl = std::move(other.mImpl);

159. return *this;

160. }

161. bool Server::start(unsigned short _port)

162. {

163. if (!mImpl)

164. mImpl = std::make_unique<ServerImpl>();

165. return mImpl && mImpl->start(_port);

166. }

167. void Server::stop() { if (mImpl) mImpl->stop(); }

168. void Server::update() { if (mImpl) mImpl->update(); }

169. bool Server::sendTo(uint64_t clientid, const unsigned char* data, unsigned int len) { return mImpl && mImpl->sendTo(clientid, data, len); }

170. bool Server::sendToAll(const unsigned char* data, unsigned int len) { return mImpl && mImpl->sendToAll(data, len); }

171. std::unique_ptr<Messages::Base> Server::poll() { return mImpl ? mImpl->poll() : nullptr; }

172. }

173. }

VI-C - Exemple d'utilisation

1. #include "Sockets.hpp"

2. #include "TCP/Server.hpp"

3. #include "Messages.hpp"

4. #include "Errors.hpp"

6. #include <iostream>

8. int main()

9. {

10. if (!Network::Start())

11. {

12. std::cout << "Erreur initialisation WinSock : " << Network::Errors::Get();

13. return -1;

14. }

16. unsigned short port;

17. std::cout << "Port ? ";

18. std::cin >> port;

20. Network::TCP::Server server;

21. if (!server.start(port))

22. {

23. std::cout << "Erreur initialisation serveur : " << Network::Errors::Get();

24. return -2;

25. }

27. while(1)

28. {

29. server.update();

30. while (auto msg = server.poll())

31. {

32. if (msg->is<Network::Messages::Connection>())

33. {

34. std::cout << "Connexion de [" << Network::GetAddress(msg->from) << ":" << Network::GetPort(msg->from) << "]" << std::endl;

35. }

36. else if (msg->is<Network::Messages::Disconnection>())

37. {

38. std::cout << "Deconnexion de [" << Network::GetAddress(msg->from) << ":" << Network::GetPort(msg->from) << "]" << std::endl;

39. }

40. else if (msg->is<Network::Messages::UserData>())

41. {

42. auto userdata = msg->as<Network::Messages::UserData>();

43. server.sendToAll(userdata->data.data(), static_cast<unsigned int>(userdata->data.size()));

44. }

45. }

46. }

47. server.stop();

48. Network::Release();

49. return 0;

50. }

Le while(1) représente la boucle principale du programme, si vous embarquez le serveur dans le code client avec un joueur qui fait office d'hôte. Si vous optez pour une machine dédiée, il s'agira vraisemblablement du main du programme comme dans cet exemple.

Ici le serveur se contente de transférer les données reçues à tous les clients connectés. Un programme plus significatif devrait désérialiser les données reçues, traiter la requête puis retourner un résultat ou non au(x) client(s).

VI-D - Code du client mis à jour

Le code de la classe Client a légèrement été mis à jour dans ce chapitre, voici une copie de l'implémentation actuelle.

VI-D-1 - Client.hpp

TCP/Client.hpp

1. #pragma once

3. #include "Sockets.hpp"

5. #include <string>

6. #include <memory>

8. namespace Network

9. {

10. namespace Messages {

11. class Base;

12. }

13. namespace TCP

14. {

15. using HeaderType = uint16_t;

16. static const unsigned int HeaderSize = sizeof(HeaderType);

17. class ClientImpl;

18. class Client

19. {

20. public:

21. Client();

22. Client(const Client&) = delete;

23. Client& operator=(const Client&) = delete;

24. Client(Client&&);

25. Client& operator=(Client&&);

26. ~Client();

28. bool init(SOCKET&& sckt, const sockaddr_in& addr);

29. bool connect(const std::string& ipaddress, unsigned short port);

30. void disconnect();

31. bool send(const unsigned char* data, unsigned int len);

32. std::unique_ptr<Messages::Base> poll();

34. uint64_t id() const;

35. const sockaddr_in& destinationAddress() const;

37. private:

38. std::unique_ptr<ClientImpl> mImpl;

39. };

40. }

41. }

VI-D-2 - Client.cpp

TCP/Client.cpp

1. #include "TCP/Client.hpp"

3. #include "Sockets.hpp"

4. #include "Messages.hpp"

5. #include "Errors.hpp"

7. #include <vector>

8. #include <list>

9. #include <cassert>

10. #include <numeric>

12. namespace Network

13. {

14. namespace TCP

15. {

16. class ConnectionHandler

17. {

18. public:

19. ConnectionHandler() = default;

20. bool connect(SOCKET sckt, const std::string& address, unsigned short port);

21. std::unique_ptr<Messages::Connection> poll();

22. const sockaddr_in& connectedAddress() const { return mConnectedAddress; }

24. private:

25. pollfd mFd{ 0 };

26. sockaddr_in mConnectedAddress;

27. std::string mAddress;

28. unsigned short mPort;

29. };

30. bool ConnectionHandler::connect(SOCKET sckt, const std::string& address, unsigned short port)

31. {

32. assert(sckt != INVALID_SOCKET);

33. mAddress = address;

34. mPort = port;

35. mFd.fd = sckt;

36. mFd.events = POLLOUT;

37. inet_pton(AF_INET, mAddress.c_str(), &mConnectedAddress.sin_addr.s_addr);

38. mConnectedAddress.sin_family = AF_INET;

39. mConnectedAddress.sin_port = htons(mPort);

40. if (::connect(sckt, (const sockaddr*)&mConnectedAddress, sizeof(mConnectedAddress)) != 0)

41. {

42. int err = Errors::Get();

43. if (err != Errors::INPROGRESS && err != Errors::WOULDBLOCK)

44. return false;

45. }

46. return true;

47. }

48. std::unique_ptr<Messages::Connection> ConnectionHandler::poll()

49. {

50. int res = ::poll(&mFd, 1, 0);

51. if (res < 0)

52. return std::make_unique<Messages::Connection>(Messages::Connection::Result::Failed);

53. else if (res > 0)

54. {

55. if (mFd.revents & POLLOUT)

56. {

57. return std::make_unique<Messages::Connection>(Messages::Connection::Result::Success);

58. }

59. else if (mFd.revents & (POLLHUP | POLLNVAL))

60. {

61. return std::make_unique<Messages::Connection>(Messages::Connection::Result::Failed);

62. }

63. else if(mFd.revents & POLLERR)

64. {

65. return std::make_unique<Messages::Connection>(Messages::Connection::Result::Failed);

66. }

67. }

68. //!< action non terminée

69. return nullptr;

70. }

71. ////////////////////////////////////////////////////////////////////////////////////

72. ////////////////////////////////////////////////////////////////////////////////////

73. ////////////////////////////////////////////////////////////////////////////////////

74. ////////////////////////////////////////////////////////////////////////////////////

75. ////////////////////////////////////////////////////////////////////////////////////

76. class ReceptionHandler

77. {

78. enum class State {

79. Header,

80. Data,

81. };

82. public:

83. ReceptionHandler() = default;

84. void init(SOCKET sckt);

85. std::unique_ptr<Messages::Base> recv();

87. private:

88. inline char* missingDataStartBuffer() { return reinterpret_cast<char*>(mBuffer.data() + mReceived); }

89. inline int missingDataLength() const { return static_cast<int>(mBuffer.size() - mReceived); }

90. void startHeaderReception();

91. void startDataReception();

92. void startReception(unsigned int expectedDataLength, State newState);

94. private:

95. std::vector<unsigned char> mBuffer;

96. unsigned int mReceived;

97. SOCKET mSckt{ INVALID_SOCKET };

98. State mState;

99. };

100. void ReceptionHandler::init(SOCKET sckt)

101. {

102. assert(sckt != INVALID_SOCKET);

103. mSckt = sckt;

104. startHeaderReception();

105. }

106. void ReceptionHandler::startHeaderReception()

107. {

108. startReception(HeaderSize, State::Header);

109. }

110. void ReceptionHandler::startDataReception()

111. {

112. assert(mBuffer.size() == sizeof(HeaderType));

113. HeaderType networkExpectedDataLength;

114. memcpy(&networkExpectedDataLength, mBuffer.data(), sizeof(networkExpectedDataLength));

115. const auto expectedDataLength = ntohs(networkExpectedDataLength);

116. startReception(expectedDataLength, State::Data);

117. }

118. void ReceptionHandler::startReception(unsigned int expectedDataLength, State newState)

119. {

120. mReceived = 0;

121. mBuffer.clear();

122. mBuffer.resize(expectedDataLength, 0);

123. mState = newState;

124. }

125. std::unique_ptr<Messages::Base> ReceptionHandler::recv()

126. {

127. assert(mSckt != INVALID_SOCKET);

128. int ret = ::recv(mSckt, missingDataStartBuffer(), missingDataLength(), 0);

129. if (ret > 0)

130. {

131. mReceived += ret;

132. if (mReceived == mBuffer.size())

133. {

134. if (mState == State::Data)

135. {

136. std::unique_ptr<Messages::Base> msg = std::make_unique<Messages::UserData>(std::move(mBuffer));

137. startHeaderReception();

138. return msg;

139. }

140. else

141. {

142. startDataReception();

143. //!< si jamais les données sont déjà disponibles elles seront ainsi retournées directement

144. return recv();

145. }

146. }

147. return nullptr;

148. }

149. else if (ret == 0)

150. {

151. //!< connexion terminée correctement

152. return std::make_unique<Messages::Disconnection>(Messages::Disconnection::Reason::Disconnected);

153. }

154. else // ret < 0

155. {

156. //!< traitement d'erreur

157. int error = Errors::Get();

158. if (error == Errors::WOULDBLOCK || error == Errors::AGAIN)

159. {

160. return nullptr;

161. }

162. else

163. {

164. return std::make_unique<Messages::Disconnection>(Messages::Disconnection::Reason::Lost);

165. }

166. }

167. }

168. ////////////////////////////////////////////////////////////////////////////////////

169. ////////////////////////////////////////////////////////////////////////////////////

170. ////////////////////////////////////////////////////////////////////////////////////

171. ////////////////////////////////////////////////////////////////////////////////////

172. ////////////////////////////////////////////////////////////////////////////////////

173. class SendingHandler

174. {

175. enum class State {

176. Idle,

177. Header,

178. Data,

179. };

180. public:

181. SendingHandler() = default;

182. void init(SOCKET sckt);

183. bool send(const unsigned char* data, unsigned int datalen);

184. void update();

185. size_t queueSize() const;

187. private:

188. bool sendPendingBuffer();

189. void prepareNextHeader();

190. void prepareNextData();

192. private:

193. std::list<std::vector<unsigned char>> mQueueingBuffers;

194. std::vector<unsigned char> mSendingBuffer;

195. SOCKET mSocket{ INVALID_SOCKET };

196. State mState{ State::Idle } ;

197. };

198. void SendingHandler::init(SOCKET sckt)

199. {

200. mSocket = sckt;

201. if (mState == State::Header || mState == State::Data)

202. {

203. mSendingBuffer.clear();

204. }

205. mState = State::Idle;

206. }

207. bool SendingHandler::send(const unsigned char* data, unsigned int datalen)

208. {

209. if (datalen > std::numeric_limits<HeaderType>::max())

210. return false;

211. mQueueingBuffers.emplace_back(data, data + datalen);

212. return true;

213. }

214. void SendingHandler::update()

215. {

216. assert(mSocket != INVALID_SOCKET);

217. if (mState == State::Idle && !mQueueingBuffers.empty())

218. {

219. prepareNextHeader();

220. }

221. while (mState != State::Idle && sendPendingBuffer())

222. {

223. if (mState == State::Header)

224. {

225. prepareNextData();

226. }

227. else

228. {

229. if (!mQueueingBuffers.empty())

230. {

231. prepareNextHeader();

232. }

233. else

234. {

235. mState = State::Idle;

236. }

237. }

238. }

239. }

240. bool SendingHandler::sendPendingBuffer()

241. {

242. if (mSendingBuffer.empty())

243. return true;

245. //!< envoi des données restantes du dernier envoi

246. int sent = ::send(mSocket, reinterpret_cast<char*>(mSendingBuffer.data()), static_cast<int>(mSendingBuffer.size()), 0);

247. if (sent > 0)

248. {

249. if (sent == mSendingBuffer.size())

250. {

251. //!< toutes les données ont été envoyées

252. mSendingBuffer.clear();

253. return true;

254. }

255. else

256. {

257. //!< envoi partiel

258. memmove(mSendingBuffer.data() + sent, mSendingBuffer.data(), sent);

259. mSendingBuffer.erase(mSendingBuffer.cbegin() + sent, mSendingBuffer.cend());

260. }

261. }

262. return false;

263. }

264. void SendingHandler::prepareNextHeader()

265. {

266. assert(!mQueueingBuffers.empty());

267. const auto header = static_cast<HeaderType>(mQueueingBuffers.front().size());

268. const auto networkHeader = htons(header);

269. mSendingBuffer.clear();

270. mSendingBuffer.resize(HeaderSize);

271. memcpy(mSendingBuffer.data(), &networkHeader, sizeof(HeaderType));

272. mState = State::Header;

273. }

274. void SendingHandler::prepareNextData()

275. {

276. assert(!mQueueingBuffers.empty());

277. mSendingBuffer.swap(mQueueingBuffers.front());

278. mQueueingBuffers.pop_front();

279. mState = State::Data;

280. }

281. size_t SendingHandler::queueSize() const

282. {

283. size_t s = std::accumulate(mQueueingBuffers.cbegin(), mQueueingBuffers.cend(), static_cast<size_t>(0), [](size_t n, const std::vector<unsigned char>& queuedItem) {

284. return n + queuedItem.size() + HeaderSize;

285. });

286. if (mState == State::Data)

287. s += mSendingBuffer.size();

288. return s;

289. }

290. ////////////////////////////////////////////////////////////////////////////////////

291. ////////////////////////////////////////////////////////////////////////////////////

292. ////////////////////////////////////////////////////////////////////////////////////

293. ////////////////////////////////////////////////////////////////////////////////////

294. ////////////////////////////////////////////////////////////////////////////////////

295. class ClientImpl

296. {

297. enum class State {

298. Connecting,

299. Connected,

300. Disconnected,

301. };

303. public:

304. ClientImpl() = default;

305. ~ClientImpl();

307. bool init(SOCKET&& sckt, const sockaddr_in& addr);

308. bool connect(const std::string& ipaddress, unsigned short port);

309. void disconnect();

310. bool send(const unsigned char* data, unsigned int len);

311. std::unique_ptr<Messages::Base> poll();

313. uint64_t id() const { return static_cast<uint64_t>(mSocket); }

314. const sockaddr_in& destinationAddress() const { return mAddress; }

316. private:

317. void onConnected(const sockaddr_in& addr);

319. private:

320. ConnectionHandler mConnectionHandler;

321. SendingHandler mSendingHandler;

322. ReceptionHandler mReceivingHandler;

323. sockaddr_in mAddress{ 0 };

324. SOCKET mSocket{ INVALID_SOCKET };

325. State mState{ State::Disconnected };

326. };

327. ClientImpl::~ClientImpl()

328. {

329. disconnect();

330. }

331. bool ClientImpl::init(SOCKET&& sckt, const sockaddr_in& addr)

332. {

333. assert(sckt != INVALID_SOCKET);

334. if (sckt == INVALID_SOCKET)

335. return false;

337. assert(mState == State::Disconnected);

338. assert(mSocket == INVALID_SOCKET);

339. if (mSocket != INVALID_SOCKET)

340. disconnect();

342. mSocket = sckt;

343. if (!SetNonBlocking(mSocket))

344. {

345. disconnect();

346. return false;

347. }

348. onConnected(addr);

349. return true;

350. }

351. bool ClientImpl::connect(const std::string& ipaddress, unsigned short port)

352. {

353. assert(mState == State::Disconnected);

354. assert(mSocket == INVALID_SOCKET);

355. if (mSocket != INVALID_SOCKET)

356. disconnect();

357. mSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

358. if (mSocket == INVALID_SOCKET)

359. {

360. return false;

361. }

362. else if (!SetNonBlocking(mSocket))

363. {

364. disconnect();

365. return false;

366. }

367. if (mConnectionHandler.connect(mSocket, ipaddress, port))

368. {

369. mState = State::Connecting;

370. return true;

371. }

372. return false;

373. }

374. void ClientImpl::disconnect()

375. {

376. if (mSocket != INVALID_SOCKET)

377. {

378. CloseSocket(mSocket);

379. }

380. mSocket = INVALID_SOCKET;

381. memset(&mAddress, 0, sizeof(mAddress));

382. mState = State::Disconnected;

383. }

384. bool ClientImpl::send(const unsigned char* data, unsigned int len)

385. {

386. return mSendingHandler.send(data, len);

387. }

388. std::unique_ptr<Messages::Base> ClientImpl::poll()

389. {

390. switch (mState)

391. {

392. case State::Connecting:

393. {

394. auto msg = mConnectionHandler.poll();

395. if (msg)

396. {

397. if (msg->result == Messages::Connection::Result::Success)

398. {

399. onConnected(mConnectionHandler.connectedAddress());

400. }

401. else

402. {

403. disconnect();

404. }

405. }

406. return msg;

407. } break;

408. case State::Connected:

409. {

410. mSendingHandler.update();

411. auto msg = mReceivingHandler.recv();

412. if (msg)

413. {

414. if (msg->is<Messages::Disconnection>())

415. {

416. disconnect();

417. }

418. }

419. return msg;

420. } break;

421. case State::Disconnected:

422. {

423. } break;

424. }

425. return nullptr;

426. }

427. void ClientImpl::onConnected(const sockaddr_in& addr)

428. {

429. mAddress = addr;

430. mSendingHandler.init(mSocket);

431. mReceivingHandler.init(mSocket);

432. mState = State::Connected;

433. }

434. ////////////////////////////////////////////////////////////////////////////////////

435. ////////////////////////////////////////////////////////////////////////////////////

436. ////////////////////////////////////////////////////////////////////////////////////

437. ////////////////////////////////////////////////////////////////////////////////////

438. ////////////////////////////////////////////////////////////////////////////////////

439. Client::Client() {}

440. Client::~Client() {}

441. Client::Client(Client&& other)

442. : mImpl(std::move(other.mImpl))

443. {}

444. Client& Client::operator=(Client&& other)

445. {

446. mImpl = std::move(other.mImpl);

447. return *this;

448. }

449. bool Client::init(SOCKET&& sckt, const sockaddr_in& addr)

450. {

451. if (!mImpl)

452. mImpl = std::make_unique<ClientImpl>();

453. return mImpl && mImpl->init(std::move(sckt), addr);

454. }

455. bool Client::connect(const std::string& ipaddress, unsigned short port)

456. {

457. if (!mImpl)

458. mImpl = std::make_unique<ClientImpl>();

459. return mImpl && mImpl->connect(ipaddress, port);

460. }

461. void Client::disconnect() { if (mImpl) mImpl->disconnect(); }

462. bool Client::send(const unsigned char* data, unsigned int len) { return mImpl && mImpl->send(data, len); }

463. std::unique_ptr<Messages::Base> Client::poll() { return mImpl ? mImpl->poll() : nullptr; }

464. uint64_t Client::id() const { return mImpl ? mImpl->id() : 0xffffffffffffffff; }

465. const sockaddr_in& Client::destinationAddress() const { static sockaddr_in empty{ 0 }; return mImpl ? mImpl->destinationAddress() : empty; }

466. }

467. }

Langue Télécharger le code source complet.

Article précédent

<< TCP - Quelle architecture de client visée ?