Cours programmation réseau en C++

TCP - Quelle architecture de client visée ?

Bousk

Dans cette partie nous allons définir l'architecture du code client que nous souhaitons utiliser.

Pour cela nous allons mettre à jour notre protocole et nos interfaces.

Commentez

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

- Auteur : Bousk

- Parution : 30 mai 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. Quel client voulons-nous ?

- I-A. Propriétés souhaitées

- I-B. Un message ?

- II. Nouvel élément : les messages

- II-A. Comment savoir de quel Message il s'agit ?

- II-A-1. Interface de conversion

- III. Comment rendre notre classe non bloquante ?

- III-A. recv

- III-B. connect

- III-C. send

- III-D. Le client

- IV. Implémentation des différents modules

- IV-A. Propriétés de la classe Client et son socket

- IV-B. Gestionnaire de connexion

- IV-B-1. bool connect(SOCKET sckt, const std::string& address, unsigned short port);

- IV-B-2. std::unique_ptr<Messages::Connection> poll();

- IV-B-2-a. Changements liés à poll sous Windows

- IV-B-3. Interface finale de ConnectionHandler

- IV-C. Gestionnaire de réception des données

- IV-C-1. std::unique_ptr<Messages::Base> recv();

- IV-C-1-a. Utilisation des membres mBuffer et mReceived

- IV-C-1-b. Implémentation de std::unique_ptr<Messages::Base> recv();

- IV-C-1-b-1. Initialiser la réception de l'en-tête

- IV-C-1-b-2. Initialiser la réception des données

- IV-C-2. Initialisation de la réception

- IV-C-3. Interface finale de ReceptionHandler

- IV-D. Gestionnaire d'envoi des données

- IV-D-1. bool send(const unsigned char* data, unsigned int datalen);

- IV-D-2. void update();

- IV-D-2-a. Utilisation de mSendingBuffer

- IV-D-2-b. Implémentation de void update();

- IV-D-2-b-1. bool sendPendingBuffer();

- IV-D-2-b-2. Initialisation de l'envoi de l'en-tête

- IV-D-2-b-3. Initialisation de l'envoi des données

- IV-D-3. void init(SOCKET sckt);

- IV-D-4. size_t queueSize() const;

- IV-D-5. Interface finale de SendingHandler

- V. Implémentation de ClientImpl

- V-A. Destructeur

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

- V-C. void disconnect();

- V-D. bool send(const unsigned char* data, unsigned int len);

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

- VI. Utilisation de Client dans le programme

I - Quel client voulons-nous ?

I-A - Propriétés souhaitées

Le client qui nous intéresse sera non bloquant pour l'application principale, et rendra les données qu'il possède disponibles à l'application sur simple requête.

Il s'agira d'un client TCP. La latence n'est donc pas une priorité et il s'adaptera plutôt pour une utilisation avec un serveur de lobby (discussions, textes…), gameplay non temps réel (Civilization, Blood Bowl) ou dans un cas où la latence n'est pas vraiment un souci et peut être absorbée. La plupart des MMO utilisent également un client TCP pour ne pas ajouter une couche supplémentaire de complexité sur la difficulté de réaliser un tel projet.

Son interface finale devrait être proche de :

Interface souhaitée pour le client

1. class TCPClient

2. {

3. public:

4. TCPClient();

5. ~TCPClient();

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

8. void disconnect();

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

10. std::unique_ptr<Message> poll();

11. };

Par rapport à l'interface mise en place dans la partie 3, vous remarquerez que Recv a disparu, laissant sa place à poll.

poll sera appelé pour extraire un Message du socket. Tout le mécanisme de réception des données et création d'un paquet complet vu dans le chapitre 3 Mise en place du protocole sera désormais interne à la bibliothèque. L'utilisateur de cette classe ne s'occupera pas de réceptionner des données arbitraires, mais directement ce que nous avions appelé un paquet, sous la dénomination de message. En pratique, l'application devra appeler poll pour récupérer le dernier message, typiquement tant qu'il y en a un disponible et agir en fonction du message reçu.

Si l'utilisation via poll ne vous convient pas, vous pouvez opter pour un système de callbacks.

Ajoutez à l'interface du client une méthode par type de callback/message existant, et modifiez poll en update pour qu'il appelle ces callbacks en interne.

Veillez simplement à également fournir une fonction pour retirer une callback.

Nous resterons pour l'instant sur cette interface. La mise en place d'une solution à base de callbacks fera éventuellement l'objet d'un chapitre à part.

I-B - Un message ?

Notre Message sera la classe de base d'une hiérarchie de cette forme :

Messages réseau

1. class Message

2. {};

3. class Connection : public Message

4. {};

5. class Disconnection : public Message

6. {};

7. class UserData : public Message

8. {};

Nous pourrons ajouter autant de types de messages que nous le souhaitons au fur et à mesure de l'évolution de notre bibliothèque, ceux-ci ne représentent que les actions basiques nécessaires jusque-là.

II - Nouvel élément : les messages

Le protocole mis en place dans le chapitre correspondant est toujours valable et sera utilisé en interne de notre bibliothèque. Il s'agit d'un détail d'implémentation dont l'utilisateur n'a à priori pas à se soucier.

Les messages servent d'abstraction entre la couche réseau et l'application. L'utilisateur de la bibliothèque travaillera avec ces messages. Leur utilité sera d'autant plus évidente quand nous implémenterons les sockets UDP, qui utiliseront également ce système de messages, permettant ainsi de passer d'une implémentation TCP à UDP avec très peu, voire aucun changement dans le code utilisateur.

Grâce à cette couche d'abstraction, l'écriture de tests devient également possible très simplement et vous pouvez fournir une interface pour simuler n'importe quel message sans même établir de connexion ni initialiser de socket.

II-A - Comment savoir de quel Message il s'agit ?

Puisque nous mettons en place du polymorphisme, il n'y aura pas beaucoup de solutions possibles. Soit avoir recours au dynamic_cast, soit proposer une interface qui le permette.

C'est cette seconde option que l'on retiendra : elle permet plus de flexibilité d'implémentation, vous pouvez vous contenter d'appeler un dynamic_cast en interne au début puis changer quand vous trouvez une solution plus performante.

II-A-1 - Interface de conversion

Nous aurons donc une interface template pour vérifier qu'un message est d'un type donné, et pouvoir l'y convertir.

L'interface aura cette forme :

Interface de conversion de Message

1. class Message

2. {

3. public:

4. template<class M>

5. bool is() const { ... }

6. template<class M>

7. const M* as() const { ... }

8. };

Une implémentation utilisant dynamic_cast pourra être :

Conversion de Message utilisant dynamic_cast

1. class Message

2. {

3. public:

4. template<class M>

5. bool is() const { return dynamic_cast<const M*>(this) != nullptr; }

6. template<class M>

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

8. };

Notez que c'est au client de s'assurer qu'une conversion est possible via un appel à is avant tout as. Vous pouvez opter pour une solution plus défensive et ajouter ce test en interne également. Une bonne pratique, qui n'apparaît pas ici, est d'ajouter ceci via un assert, afin que le test soit réalisé en configuration de débogage, puis retiré lors de la compilation de la version finale.

Je vous propose une autre implémentation qui n'utilise pas dynamic_cast, réputé lent et nécessitant le RTTI (RunTime Type Information) qui est parfois désactivé dans un souci de performance et dont l'implémentation dépend de la plateforme. (Voir cette discussion sur StackOverflow traitant du RTTI en C++.)

Vu le faible nombre de messages, tous connus et internes à la couche réseau (l'application cliente ne pourra pas en définir), j'utilise une implémentation toute simple à base d'énumération, et quelques macros d'aide pour la génération de code :

Implémentation à base d'énumération

1. #define DECLARE_MESSAGE(name) friend class Message; static const Message::Type StaticType = Message::Type::name

2. class Message

3. {

4. public:

5. template<class M>

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

7. template<class M>

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

10. protected:

11. enum class Type {

12. Connection,

13. Disconnection,

14. UserData,

15. };

16. Message(Type type)

17. : mType(type)

18. {}

19. private:

20. Type mType;

21. };

22. class Connection : public Message

23. {

24. DECLARE_MESSAGE(Connection);

25. public:

26. Connection()

27. : Message(Type::Connection)

28. {}

29. };

30. class Disconnection : public Message

31. {

32. DECLARE_MESSAGE(Disconnection);

33. public:

34. Disconnection()

35. : Message(Type::Disconnection)

36. {}

37. };

38. class UserData : public Message

39. {

40. DECLARE_MESSAGE(UserData);

41. public:

42. UserData()

43. : Message(Type::UserData)

44. {}

45. };

46. #undef DECLARE_MESSAGE

Le constructeur n'est pas public afin que l'on ne puisse pas créer un Message basique, mais uniquement un Message dérivé qui eux sont correctement définis. De même les types sont dans la portée protected afin que les classes dérivées puissent utiliser ces valeurs dans leur appel au constructeur de base, mais qu'ils ne soient pas accessibles par l'utilisateur.

Enfin la macro se chargera de définir une variable statique StaticType qui contiendra le Type de message de cette classe et déclarer une amitié de la classe dérivée vers la classe de base afin que cette variable soit accessible dans la fonction is, sans être accessible publiquement. StaticType est donc dans la portée private de la classe dérivée.

Finalement, par pure préférence personnelle, plaçons le tout dans un espace de nommage (namespace) approprié Messages et renommons Message en Base. Ajoutons également dès à présent des données supplémentaires qui nous seront utiles plus tard :

Messages.hpp

1. namespace Messages

2. {

3. #define DECLARE_MESSAGE(name) friend class Base; static const Base::Type StaticType = Base::Type::name

4. class Base

5. {

6. public:

7. template<class M>

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

9. template<class M>

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

11. template<class M>

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

14. protected:

15. enum class Type {

16. Connected,

17. ConnectionFailed,

18. Disconnected,

19. UserData,

20. };

21. Base(Type type)

22. : mType(type)

23. {}

24. private:

25. Type mType;

26. };

27. class Connection : public Base

28. {

29. DECLARE_MESSAGE(Connection);

30. public:

31. enum class Result {

32. Success,

33. Failed,

34. };

35. Connection(Result r)

36. : Base(Type::Connection)

37. , result(r)

38. {}

39. Result result;

40. };

41. class Disconnection : public Base

42. {

43. DECLARE_MESSAGE(Disconnection);

44. public:

45. enum class Reason {

46. Disconnected,

47. Lost,

48. };

49. Disconnection(Reason r)

50. : Base(Type::Disconnection)

51. , reason(r)

52. {}

53. Reason reason;

54. };

55. class UserData : public Base

56. {

57. DECLARE_MESSAGE(UserData);

58. public:

59. UserData(std::vector<unsigned char>&& d)

60. : Base(Type::UserData)

61. , data(std::move(d))

62. {}

63. std::vector<unsigned char> data;

64. };

65. #undef DECLARE_MESSAGE

66. }

III - Comment rendre notre classe non bloquante ?

III-A - recv

recv est le plus simple aspect à traiter ici. Que l'on choisisse d'utiliser le mode non bloquant ou select ou poll, son comportement est très similaire et permet de réceptionner une partie des données demandées. Puisque les données peuvent être réceptionnées par fragments, on devra user d'un tampon interne pour les sauvegarder entre chaque appel.

Notre protocole utilise un en-tête indiquant la taille des données, avant d'envoyer les données elles-mêmes, et chacune de ces données peut être fragmentée. Une très simple machine à état sera utilisée pour indiquer si nous sommes en train de réceptionner un en-tête ou des données.

Pour simplifier la mise en place de ce mécanisme, ayons recours à une classe de cette forme :

Gestionnaire de réception des données

1. class ReceptionHandler

2. {

3. enum class State {

4. Header,

5. Data,

6. };

7. public:

8. ReceptionHandler(SOCKET sckt);

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

11. private:

12. size_t missingData() const { return mBuffer.size() - mReceived; }

14. private:

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

16. unsigned int mReceived;

17. SOCKET mSocket;

18. State mState;

19. };

recv retourne directement le dernier message disponible, s'il y en a. En cas de déconnexion survenue, il sera capable de déterminer l'éventuelle erreur et retournera le message de déconnexion correspondant.

Tant que notre client est connecté, il suffira d'appeler cette méthode pour récupérer les données. Si un message est retourné, vérifiez s'il s'agit d'un message de déconnexion ou non pour modifier l'état de notre client avant de le retourner à l'application.

Toute la gestion de la taille du message, de la quantité de données manquantes, de la réception de l'en-tête et du passage du mode de réception de l'en-tête aux données sera interne à cette classe.

III-B - connect

Afin de rendre le connect non bloquant et aisément interruptible, nous utiliserons poll comme introduit au chapitre précédent.

Et pourquoi ne pas limiter et encapsuler cette gestion dans sa propre classe ? Par exemple un premier jet pourrait être :

Gestionnaire de connexion

1. class ConnectionHandler

2. {

3. public:

4. ConnectionHandler(SOCKET sckt);

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

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

8. private:

9. pollfd mFd;

10. std::string mAddress;

11. unsigned short mPort;

12. };

Cette interface permet de connecter un socket donné à une adresse et port. connect pouvant échouer dès son appel, la valeur de retour sera utilisée pour déterminer si la connexion a été démarrée ou non. Ensuite il faut vérifier régulièrement, typiquement à chaque frame, si la connexion est finalement établie, ou a échoué en vérifiant si poll retourne un message et le champ result de celui-ci.

Grâce à cette interface à utilisation asynchrone, il sera plus simple de faire évoluer notre code par la suite. Pour l'instant nous nous sommes toujours connectés à une adresse IP directement, et nous continuerons ainsi pour le moment. Si nous voulons utiliser un nom d'hôte à la place, il faudra retrouver l'IP derrière cet hôte, ce qui est une opération asynchrone. Comme notre interface l'est déjà, le résultat sera différé pour l'utilisateur, mais il n'aura pas, ou que très peu, à changer l'utilisation qu'il en fait.

La sauvegarde de l'adresse et du port est optionnelle. Ils seront directement utilisés dans l'appel à connect, mais il est pratique de les garder en mémoire si on a besoin d'y accéder par la suite.

Le socket n'est apparemment pas sauvegardé, mais sera en fait enregistré dans le champ fd de la structure mFd utilisée pour l'appel à poll. Inutile donc de dupliquer cette information.

III-C - send

Enfin la dernière partie nécessaire à l'utilisation de notre socket : l'envoi de données. La difficulté réside dans la gestion des envois partiels et des erreurs non bloquantes qui nécessitent de renvoyer respectivement les données manquantes et la totalité des données.

Afin de décharger l'application de ces vérifications, ce mécanisme sera également géré en interne. Ce qui signifie qu'on devra user d'un tampon interne pour stocker les données avant que leur envoi ne soit effectif s'il n'est pas possible de les envoyer directement. Toute la mise en place du protocole, symétrique à la réception (en-tête suivi des données) sera également gérée en interne.

Ceci permettra également d'avoir certaines informations sur notre connexion : nous pourrons déterminer à chaque instant la quantité de données en file d'attente, ce qui peut être pratique pour les contrôles et éviter de noyer notre couche réseau. Vous pouvez ainsi limiter la file et générer des erreurs si elle atteint une taille critique, et avoir une idée à tout moment de la quantité de données que vous envoyez.

Vous pourrez aller plus loin en ajoutant par exemple une notion de durée de vie à chaque envoi, si des données n'ont pas été envoyées après un temps donné vous pouvez les ignorer et passer directement aux suivantes. Mais ceci sort du cadre de ce chapitre.

La structure d'une telle classe pourrait être :

Gestionnaire d'envoi des données

1. class SendingHandler

2. {

3. enum class State {

4. Idle,

5. Header,

6. Data,

7. };

8. public:

9. SendingHandler(SOCKET sckt);

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

11. void update();

12. size_t queueSize() const;

14. private:

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

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

17. State mState;

18. };

L'appel à send devra mettre en file d'attente les données à envoyer, si possible. Une valeur retour false indiquera que les données ont été rejetées et ne seront pas envoyées.

Ensuite il convient d'appeler update régulièrement, typiquement à chaque frame. Cette fonction se chargera de l'envoi effectif des données quand possible, d'envoyer l'en-tête avant les données réelles et prendra en charge les envois partiels éventuels.

Contrairement aux classes ConnectionHandler et ReceivingHandler, nous n'avons aucune gestion d'erreur explicite ici. La raison est que cette classe est faite pour travailler en binôme avec la classe ReceivingHandler, et ce sera cette dernière qui nous informera d'une erreur.

Si vous souhaitez utiliser cette classe seule, dans le cadre d'un socket amené uniquement à envoyer des données et ne jamais en recevoir, vous pourrez par exemple changer la signature de la fonction update pour retourner un bool indiquant que la connexion a été terminée s'il vaut false, ou est toujours valide s'il vaut true.

III-D - Le client

Avec toutes ces spécificités internes, le pattern pimpl (pointer to implementation : pointeur vers l'implémentation) est un bon candidat : il permettra de modifier les mécanismes internes à notre guise sans avoir à changer l'interface publique de notre classe client.

Voici donc à quoi devrait ressembler notre en-tête :

En-tête du client TCP

1. #pragma once

3. #include <string>

4. #include <memory>

6. namespace Network

7. {

8. namespace Messages {

9. class Base;

10. }

11. namespace TCP

12. {

13. using HeaderType = uint16_t;

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

15. class ClientImpl;

16. class Client

17. {

18. public:

19. Client();

20. ~Client();

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

23. void disconnect();

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

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

27. private:

28. std::unique_ptr<ClientImpl> mImpl;

29. };

30. }

31. }

Les informations concernant l'en-tête d'un paquet sont également rendues disponibles publiquement dans ce fichier pour simplifier leur utilisation dans les différents modules et si un utilisateur souhaite y accéder pour quelconque raison (information de débogage…).

IV - Implémentation des différents modules

IV-A - Propriétés de la classe Client et son socket

Notre classe possédera un constructeur par défaut qui n'initialisera pas le socket.

Le socket sera initialisé sur appel à connect uniquement et pas avant. Si l'initialisation du socket échoue, connect retournera directement false sans tenter d'amorcer la connexion.

Notre classe ne sera pas copiable. Sa destruction entraînera la fermeture du socket interne s'il était utilisé. Elle sera par contre déplaçable.

Le socket de notre classe Client utilisera le mode non bloquant. Ceci par pure préférence personnelle, vous pouvez très bien utiliser select ou poll pour l'envoi et la réception également.

Notre en-tête de Client sera de cette forme :

En-tête du client TCP

1. #pragma once

3. #include <string>

4. #include <memory>

6. namespace Network

7. {

8. namespace Messages {

9. class Base;

10. }

11. namespace TCP

12. {

13. using HeaderType = uint16_t;

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

15. class ClientImpl;

16. class Client

17. {

18. public:

19. Client();

20. Client(const Client&) = delete;

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

22. Client(Client&&);

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

24. ~Client();

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

27. void disconnect();

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

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

31. private:

32. std::unique_ptr<ClientImpl> mImpl;

33. };

34. }

35. }

Au niveau de l'implémentation, il s'agit juste de transférer les appels au pointeur mImpl qui se charge d'implémenter réellement les mécanismes :

Client.cpp

1. namespace Network

2. {

3. namespace TCP

4. {

5. Client::Client() {}

6. Client::~Client() {}

7. Client::Client(Client&& other) : mImpl(std::move(other.mImpl) {}

8. Client& Client::operator=(Client&& other) { mImpl = std::move(other.mImpl); return *this; }

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

10. {

11. if (!mImpl)

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

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

14. }

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

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

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

18. }

19. }

Assurez-vous juste de vérifier que le pointeur mImpl est toujours valide avant d'y accéder. Puisque notre classe propose les interfaces de déplacement, il peut se retrouver invalidé si elle a été déplacée - ou non initialisée.

L'initialisation du pointeur interne sera faite sur appel à connect uniquement, afin de limiter la mémoire utilisée si notre client n'est pas initialisé et pouvoir réutiliser et reconnecter un client déplacé.

IV-B - Gestionnaire de connexion

IV-B-1 - bool connect(SOCKET sckt, const std::string& address, unsigned short port);

Notre fonction connect prend en paramètre l'adresse, qui devra être, pour le moment, uniquement une adresse IP, et le port du serveur auquel se connecter.

Puisque notre classe Client initialise son socket tardivement, il n'est pas possible de créer directement un ConnectionHandler avec le socket sans user d'allocation dynamique. On ajoute donc le socket à utiliser en paramètre de connect.

Elle retournera true si la connexion a été amorcée, false sinon.

Point de vue implémentation, il s'agit d'une copie adaptée du chapitre précédent :

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

2. {

3. assert(sckt != INVALID_SOCKET);

4. mAddress = address;

5. mPort = port;

6. mFd.fd = sckt;

7. mFd.events = POLLOUT;

8. sockaddr_in server;

9. inet_pton(AF_INET, mAddress.c_str(), &server.sin_addr.s_addr);

10. server.sin_family = AF_INET;

11. server.sin_port = htons(mPort);

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

13. {

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

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

16. return false;

17. }

18. return true;

19. }

Avec cette implémentation, seule la connexion à une adresse IPv4 est possible.

Cette classe sera étendue par la suite pour permettre de se connecter à des adresses IPv6, mais également à un nom d'hôte en recherchant l'IP de l'hôte.

IV-B-2 - std::unique_ptr<Messages::Connection> poll();

Notre fonction poll retournera nullptr tant que la connexion est en cours.

Une fois la connexion terminée, ou échouée, elle retournera le Messages::Connection correspondant en déterminant l'éventuelle erreur survenue afin de remplir le champ Reason du message.

Implémentation de poll

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

2. {

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

4. if (res < 0)

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

6. else if (res > 0)

7. {

8. if (mFd.revents & POLLOUT)

9. {

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

11. }

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

13. {

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

15. }

16. else if(mFd.revents & POLLERR)

17. {

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

19. }

20. }

21. //!< action non terminée

22. return nullptr;

23. }

Pour l'instant très simple, Reason peut valoir uniquement Success ou Failed. Mais par la suite nous pourrons ajouter une durée limitée et avoir un TimeOut, ou bien échouer à traduire le nom d'hôte en IP. Libre à vous d'ajouter la granularité de vos possibilités sur les erreurs possibles selon votre plateforme par exemple.

IV-B-2-a - Changements liés à poll sous Windows

Dans le chapitre introduisant poll, nous nous étions contentés d'un #define poll WSAPoll sous Windows pour uniformiser la syntaxe d'appel avec les systèmes Unix.

Puisque poll est maintenant une fonction de notre interface, un simple define ne peut plus convenir. Ce n'était de toute façon qu'une écriture quick & dirty qui n'était pas faite pour durer : les macros de ce genre, à fortiori sur une fonction aussi banale et commune, peuvent vite dégénérer et modifier un code à l'insu de l'utilisateur.

Changeons donc dès à présent sa déclaration pour rediriger l'appel vers WSAPoll convenablement. #define poll WSAPoll devient donc inline int poll(pollfd fdarray[], nfds_t nfds, int timeout) { return WSAPoll(fdarray, nfds, timeout); }.

Je choisis de la déclarer inline par simplicité principalement. Vous pouvez tout aussi bien avoir le seul prototype dans l'en-tête int poll(pollfd fdarray[], nfds_t nfds, int timeout); et son implémentation dans un fichier cpp, en s'assurant qu'elle soit limitée à Windows :

Implémentation de poll pour Windows

1. #ifdef _WIN32

2. int poll(pollfd fdarray[], nfds_t nfds, int timeout)

3. {

4. return WSAPoll(fdarray, nfds, timeout);

5. }

6. #endif

IV-B-3 - Interface finale de ConnectionHandler

L'interface finale est très proche de celle introduite dans la première partie de ce chapitre. Le résultat avec l'initialisation des variables membres est :

Interface finale de ConnectionHandler

1. namespace Network

2. {

3. namespace TCP

4. {

5. class ConnectionHandler

6. {

7. public:

8. ConnectionHandler() = default;

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

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

12. private:

13. pollfd mFd{ 0 };

14. std::string mAddress;

15. unsigned short mPort;

16. };

17. }

18. }

IV-C - Gestionnaire de réception des données

IV-C-1 - std::unique_ptr<Messages::Base> recv();

Notre fonction recv doit assurer la bonne mise en place de notre protocole.

Notre protocole se caractérise par l'envoi d'un en-tête qui contient la taille du paquet à suivre, codé sur 16 bits, puis les données.

Une fois la connexion effectuée, les premières données que nous recevrons seront forcément un en-tête. Après réception de l'en-tête complet, nous savons quelle quantité de données nous devons nous attendre à recevoir pour le paquet.

Une fois la réception des données terminées, nous avons un paquet entier disponible que nous pouvons transmettre à l'application via un Messages::UserData, et nous pouvons repasser en mode réception de l'en-tête suivant.

IV-C-1-a - Utilisation des membres mBuffer et mReceived

À chaque instant, mBuffer servira de tampon de réception. Puisque nous connaissons toutes les données à recevoir, un sizeof(uint16_t) pour l'en-tête et la valeur de l'en-tête pour les données, nous pouvons préparer ce tampon à la taille convenable en utilisant std::vector::resize.

mReceived enregistrera les données déjà reçues.

La quantité de données manquantes sera tout simplement la différence entre la taille de mBuffer et la valeur de mReceived : int missingDataLength() const { return static_cast<int>(mBuffer.size() - mReceived); }.

De la même manière, pour savoir où se situer dans le tampon pour la réception, il suffira de décaler de mReceived le pointeur de mBuffer : char* missingDataStartBuffer() { return reinterpret_cast<char*>(mBuffer.data() + mReceived); }.

IV-C-1-b - Implémentation de std::unique_ptr<Messages::Base> recv();

recv se chargera de la réception des données dans mBuffer, dont l'utilisation a été expliquée dans le paragraphe précédent et de retourner les données quand elles ont été intégralement reçues dans un Messages::UserData.

recv servira également à intercepter les déconnexions et retournera un Messages::Disconnection correspondant si cela se produit.

Finalement, si aucune donnée n'a été reçue ou que le paquet n'est pas encore prêt - pas encore réceptionné entièrement - et que la connexion est toujours valide, la valeur de nullptr sera retournée.

Implémentation de recv

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

2. {

3. assert(mSckt != INVALID_SOCKET);

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

5. if (ret > 0)

6. {

7. mReceived += ret;

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

9. {

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

11. {

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

13. startHeaderReception();

14. return msg;

15. }

16. else

17. {

18. startDataReception();

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

20. return recv();

21. }

22. }

23. return nullptr;

24. }

25. else if (ret == 0)

26. {

27. //!< connexion terminée correctement

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

29. }

30. else // ret < 0

31. {

32. //!< traitement d'erreur

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

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

35. {

36. return nullptr;

37. }

38. else

39. {

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

41. }

42. }

43. }

Nous commençons par réceptionner des données, en limitant à la quantité que nous attendons. Si des données ont été reçues, nous mettons à jour mReceived.

Si nous avons reçu la quantité de données attendues, mReceived == mBuffer.size(), alors le paquet est complet. Commence alors le traitement du paquet en question.

Si nous étions en mode en-tête, mState == State::Header, nous commençons immédiatement à récupérer les données du paquet. Si nous étions déjà en mode données, mState == State::Data, nous retournons au mode réception du prochain en-tête et créons le message pour l'application.

IV-C-1-b-1 - Initialiser la réception de l'en-tête

Notre en-tête sera une donnée comme une autre à réceptionner. La seule différence réside dans l'état de notre receveur qui sera en mode State::Header.

Sa taille est connue, puisque décidée par nous-mêmes lors de l'élaboration de la bibliothèque, et vaut 16 bits, sizeof(uint16_t) octets (2 octets sur à peu près toutes les machines standards).

1. void ReceptionHandler::startHeaderReception()

2. {

3. mReceived = 0;

4. mBuffer.clear();

5. mBuffer.resize(HeaderSize, 0);

6. mState = State::Header;

7. }

IV-C-1-b-2 - Initialiser la réception des données

Après réception de l'en-tête, le tampon contiendra la valeur de la quantité de données à attendre pour le prochain paquet, enregistrée en boutisme réseau qu'il faudra donc convertir en boutisme local.

1. void ReceptionHandler::startDataReception()

2. {

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

4. HeaderType networkExpectedDataLength;

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

6. const auto expectedDataLength = ntohs(networkExpectedDataLength);

7. mReceived = 0;

8. mBuffer.clear();

9. mBuffer.resize(expectedDataLength, 0);

10. mState = State::Data;

11. }

Vu la similitude, sans grande surprise, de ces deux fonctions, nous pouvons les factoriser ainsi afin de limiter les erreurs :

Factorisation de la réception des en-têtes et des données

1. void ReceptionHandler::startHeaderReception()

2. {

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

4. }

5. void ReceptionHandler::startDataReception()

6. {

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

8. HeaderType networkExpectedDataLength;

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

10. const auto expectedDataLength = ntohs(networkExpectedDataLength);

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

12. }

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

14. {

15. mReceived = 0;

16. mBuffer.clear();

17. mBuffer.resize(expectedDataLength, 0);

18. mState = newState;

19. }

Ce qui renforce la remarque initiale : l'en-tête est une donnée à récupérer comme une autre.

IV-C-2 - Initialisation de la réception

Une fois notre socket connecté, nous devons initialiser la réception des données. Ajoutons donc une fonction init à notre ReceptionHandler afin d'indiquer le socket sur lequel travailler et démarrer la réception des données, ou plutôt de l'en-tête :

1. void ReceptionHandler::init(SOCKET sckt)

2. {

3. assert(sckt != INVALID_SOCKET);

4. mSckt = sckt;

5. startHeaderReception();

6. }

IV-C-3 - Interface finale de ReceptionHandler

Interface finale de ReceptionHandler

1. class ReceptionHandler

2. {

3. enum class State {

4. Header,

5. Data,

6. };

7. public:

8. ReceptionHandler() = default;

9. void init(SOCKET sckt);

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

12. private:

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

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

15. void startHeaderReception();

16. void startDataReception();

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

19. private:

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

21. unsigned int mReceived;

22. SOCKET mSckt{ INVALID_SOCKET };

23. State mState;

24. };

IV-D - Gestionnaire d'envoi des données

IV-D-1 - bool send(const unsigned char* data, unsigned int datalen);

La fonction send validera les données avant de les mettre en file d'attente d'envoi et retourner true, ou les ignorer et retourner false. Les données seront dans une liste FIFO - First In, First Out - : elles seront envoyées dans l'ordre de leur passage à send.

Pour l'instant la seule limitation à l'envoi de nos données est que leur quantité ne dépasse pas la taille de l'en-tête du protocole : la valeur maximale stockable dans un uint16_t.

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

2. {

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

4. return false;

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

6. return true;

7. }

IV-D-2 - void update();

update sera le cœur de l'implémentation de l'envoi des données. Il s'agira d'envoyer autant de données que possible à chaque appel.

Si un envoi est en cours, que l'envoi précédent n'a été que partiel, nous devons renvoyer les données manquantes.

Si aucune donnée n'est en cours d'envoi, nous envoyons les données suivantes dans la file d'envoi si elle n'est pas vide.

En cas d'erreur, nous l'ignorons et abandonnons l'opération en cours. L'erreur sera interceptée et traitée par le gestionnaire de réception.

IV-D-2-a - Utilisation de mSendingBuffer

mSendingBuffer sera à chaque instant notre tampon à envoyer. Quand nous voudrons envoyer des données, nous les placerons dans ce tampon. Pour connaître la quantité de données restant à envoyer, il s'agira de la taille du tampon. Après chaque envoi réussi, il faudra donc l'amputer d'autant afin de garder ses informations cohérentes.

IV-D-2-b - Implémentation de void update();

1. void SendingHandler::update()

2. {

3. assert(mSocket != INVALID_SOCKET);

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

5. {

6. prepareNextHeader();

7. }

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

9. {

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

12. {

13. prepareNextData();

14. }

15. else

16. {

17. if (!mQueueingBuffers.empty())

18. {

19. prepareNextHeader();

20. }

21. else

22. {

23. mState = State::Idle;

24. }

25. }

26. }

27. }

Notre classe débute toujours en état Idle, la première partie commencera l'envoi des données après un arrêt et l'initialisation, si des données ont été mises en file d'envoi depuis.

Ensuite, tant que nous ne sommes pas en arrêt, nous envoyons les données en cours. sendPendingBuffer se charge d'envoyer les données en cours et retourne true si toutes les données ont été envoyées, et que nous pouvons passer à la suite, false sinon.

Si l'envoi en cours est terminé et que nous étions en mode d'envoi de l'en-tête, mState == State::Header, on démarre l'envoi des données actuellement mises en file et attendues par l'utilisateur. Si nous étions déjà en mode envoi des données, mState == State::Data, et qu'il reste des données en attente d'envoi, on repasse en mode en-tête et continuons l'envoi. Sinon on repasse à l'arrêt et en attente de données.

IV-D-2-b-1 - bool sendPendingBuffer();

Cette fonction devra envoyer les données manquantes de l'envoi en cours et retournera true si toutes les données ont été envoyées, false si l'envoi n'a été que partiel et que des données restent à envoyer.

1. bool SendingHandler::sendPendingBuffer()

2. {

3. if (mSendingBuffer.empty())

4. return true;

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

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

8. if (sent > 0)

9. {

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

11. {

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

13. mSendingBuffer.clear();

14. return true;

15. }

16. else

17. {

18. //!< envoi partiel

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

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

21. }

22. }

23. return false;

24. }

Petite astuce : plutôt que de supprimer les données en début de tampon après leur envoi, il est plus efficace de déplacer les données au début du vector afin d'en supprimer la fin.

IV-D-2-b-2 - Initialisation de l'envoi de l'en-tête

D'après les propriétés de notre protocole, l'en-tête est un entier uint16_t qui représente la taille - la quantité de données - du paquet à venir. Le paquet à venir étant le premier paquet présent dans mQueueingBuffers.

La préparation de l'envoi de l'en-tête sera le miroir du code de leur réception du paragraphe précédent :

Préparation de l'envoi de l'en-tête

1. void SendingHandler::prepareNextHeader()

2. {

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

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

5. const auto networkHeader = htons(header);

6. mSendingBuffer.clear();

7. mSendingBuffer.resize(HeaderSize);

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

9. mState = State::Header;

10. }

On s'assure de convertir en boutisme réseau la taille avant de la copier dans le tampon d'envoi, puis on change l'état en envoi d'en-tête.

IV-D-2-b-3 - Initialisation de l'envoi des données

Les données seront celles présentes en tête de mQueueingBuffer. Préparer les données à l'envoi reviendra à copier ces données dans le tampon d'envoi, puis modifier l'état de l'envoyeur en mode données :

Préparation de l'envoi des données

1. void SendingHandler::prepareNextData()

2. {

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

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

5. mQueueingBuffers.pop_front();

6. mState = State::Data;

7. }

Si vous comptez appeler send et update dans des threads différents, il faudra synchroniser les opérations sur mQueueingBuffers avec un mutex.

IV-D-3 - void init(SOCKET sckt);

Tout comme pour la réception, il faudra initialiser notre gestionnaire d'envoi après connexion.

1. void SendingHandler::init(SOCKET sckt)

2. {

3. mSocket = sckt;

4. mQueueingBuffers.clear();

5. mSendingBuffer.clear();

6. mState = State::Idle;

7. }

Cette version purgera toutes les données qui seraient toujours en file lors de l'appel. En cas de reconnexion par exemple.

Si vous préférez pouvoir garder les données précédemment mises en file, vous pouvez opter pour cette implémentation :

1. void SendingHandler::init(SOCKET sckt)

2. {

3. mSocket = sckt;

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

5. {

6. mSendingBuffer.clear();

7. }

8. mState = State::Idle;

9. }

Les données qui étaient en cours d'envoi ne peuvent malheureusement pas être conservées, on ignore ce qui a réellement été transmis ou non, il faudra donc les purger dans tous les cas.

De même, comme l'application n'a aucune idée de ce qui a été envoyé ou non, à moins de recevoir une réponse du serveur, il n'est pas forcément avantageux de garder les envois précédents en cas de reconnexion. Ce n'est donc pas l'implémentation que je conseille ou utiliserai dans ce cours.

IV-D-4 - size_t queueSize() const;

Voici une implémentation de la fonction utilitaire présentée plus tôt afin de connaître la quantité de données en file d'envoi :

1. #include <numeric>

2. size_t SendingHandler::queueSize() const

3. {

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

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

6. });

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

8. s += mSendingBuffer.size();

9. return s;

10. }

Retourne la quantité de données actuellement en file d'envoi. N'oubliez pas d'ajouter la taille de l'en-tête pour chaque donnée. Si des données sont actuellement en train d'être envoyées, il faut aussi les ajouter au total.

Si le gestionnaire est en train d'envoyer un en-tête, cette implémentation retournera une valeur erronée d'une poignée d'octets, ce qui n'est pas bien grave étant donné la rareté de la chose (le gestionnaire d'envoi devrait se trouver dans un état en-tête qu'extrêmement rarement, puisqu'il enverra l'en-tête avec succès avant d'immédiatement retourner en état envoi de données l'immense majorité du temps) et que ce résultat n'est toujours qu'une information sur l'état de nos échanges plus qu'une donnée réelle.

IV-D-5 - Interface finale de SendingHandler

Interface finale de SendingHandler

1. class SendingHandler

2. {

3. enum class State {

4. Idle,

5. Header,

6. Data,

7. };

8. public:

9. SendingHandler() = default;

10. void init(SOCKET sckt);

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

12. void update();

13. size_t queueSize() const;

15. private:

16. bool sendPendingBuffer();

17. void prepareNextHeader();

18. void prepareNextData();

20. private:

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

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

23. SOCKET mSocket{ INVALID_SOCKET };

24. State mState{ State::Idle } ;

25. };

V - Implémentation de ClientImpl

Maintenant que nos différents modules sont implémentés, il est temps de les connecter et de les utiliser dans notre implémentation ClientImpl.

Notre interface devrait ressembler à :

1. class ClientImpl

2. {

3. enum class State {

4. Connecting,

5. Connected,

6. Disconnected,

7. };

9. public:

10. ClientImpl()= default;

11. ~ClientImpl();

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

14. void disconnect();

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

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

18. private:

19. ConnectionHandler mConnectionHandler;

20. SendingHandler mSendingHandler;

21. ReceptionHandler mReceivingHandler;

22. SOCKET mSocket{ INVALID_SOCKET };

23. State mState{ State::Disconnected };

24. };

Nous n'avons fait que reprendre l'interface de la classe Client et avons ajouté les différents membres pour chaque module, le socket et une machine à état, que nous initialisons aux valeurs par défaut de INVALID_SOCKET et Disconnected.

V-A - Destructeur

Le destructeur n'aura qu'à s'assurer que notre socket est correctement déconnecté et libéré :

1. ClientImpl::~ClientImpl()

2. {

3. disconnect();

4. }

La logique pour vérifier que le socket est déjà déconnecté ou non sera à l'intérieur de la fonction disconnect.

V-B - bool connect(const std::string& ipaddress, unsigned short port);

connect devra initialiser le socket puis amorcer la connexion via le module de ConnectionHandler.

Pour l'initialisation d'un socket, souvenez-vous du premier chapitre à ce sujet.

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

2. {

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

4. assert(mSocket == INVALID_SOCKET);

5. if (mSocket != INVALID_SOCKET)

6. disconnect();

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

8. if (mSocket == INVALID_SOCKET)

9. {

10. return false;

11. }

12. else if (!SetNonBlocking(mSocket))

13. {

14. disconnect();

15. return false;

16. }

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

18. {

19. mState = State::Connecting;

20. return true;

21. }

22. return false;

23. }

Cette fonction ne devrait être appelée que sur un Client déconnecté, d'où les assertions des premières lignes.

Cependant, pour simplifier l'utilisation et ne pas perturber le fonctionnement en cas de problème, on s'assurera de simplement déconnecter le socket s'il était déjà utilisé.

V-C - void disconnect();

Cette fonction aura deux objectifs : libérer le socket et réinitialiser l'état de la classe à Disconnected.

1. void ClientImpl::disconnect()

2. {

3. if (mSocket != INVALID_SOCKET)

4. {

5. CloseSocket(mSocket);

6. }

7. mSocket = INVALID_SOCKET;

8. mState = State::Disconnected;

9. }

CloseSocket pourrait être appelé dans tous les cas, il n'aurait aucun effet si le socket était déjà déconnecté. Mais il est toujours plus clair de réaliser le test et éviter d'avoir des erreurs inutiles si on veut récupérer une erreur.

V-D - bool send(const unsigned char* data, unsigned int len);

Ici il y a une seule chose à faire : rediriger l'appel vers le gestionnaire d'envoi :

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

2. {

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

4. }

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

Enfin, le cœur du client, qui s'assure du bon fonctionnement des différents modules et changement d'état correspondant quand nécessaire.

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

2. {

3. switch (mState)

4. {

5. case State::Connecting:

6. {

7. auto msg = mConnectionHandler.poll();

8. if (msg)

9. {

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

11. {

12. mSendingHandler.init(mSocket);

13. mReceivingHandler.init(mSocket);

14. mState = State::Connected;

15. }

16. else

17. {

18. disconnect();

19. }

20. }

21. return msg;

22. } break;

23. case State::Connected:

24. {

25. mSendingHandler.update();

26. auto msg = mReceivingHandler.recv();

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

28. {

29. disconnect();

30. }

31. return msg;

32. } break;

33. case State::Disconnected:

34. {

35. } break;

36. }

37. return nullptr;

38. }

Tant que la connexion est en cours, seul le gestionnaire de connexion est utilisé. Nous nous contentons d'appeler sa méthode poll pour récupérer le résultat de la connexion dès qu'il est disponible.

Si la connexion est réussie, nous initialisons le gestionnaire d'envoi et de réception et changeons l'état à Connected. Sinon on déconnecte et réinitialise le client.

Une fois le client connecté, nous mettons à jour le gestionnaire d'envoi pour traiter la file d'envoi, puis nous récupérons un éventuel message reçu. S'il s'agit d'un message de déconnexion, nous réinitialisons le client. Dans tous les cas, ce message est retourné au programme principal.

VI - Utilisation de Client dans le programme

Nous avons désormais accès à une écriture du code bien plus agréable et simple.

Voici un programme minimal utilisant cette nouvelle implémentation créée lors de ce chapitre :

Programme utilisant le nouveau Client

1. #include "Sockets.hpp"

2. #include "TCP/Client.hpp"

3. #include "Messages.hpp"

4. #include "Errors.hpp"

6. #include <iostream>

8. int main()

9. {

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

11. {

12. std::cout << "Error starting sockets : " << Network::Errors::Get() << std::endl;

13. return -1;

14. }

16. Network::TCP::Client client;

17. int port;

18. std::cout << "Port du serveur ? ";

19. std::cin >> port;

20. if (!client.connect("127.0.0.1", port))

21. {

22. std::cout << "Impossible de se connecter au serveur [127.0.0.1:" << port << "] : " << Network::Errors::Get() << std::endl;

23. }

24. else

25. {

26. while (1)

27. {

28. while (auto msg = client.poll())

29. {

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

31. {

32. auto connection = msg->as<Network::Messages::Connection>();

33. if (connection->result == Network::Messages::Connection::Result::Success)

34. {

35. std::cin.ignore();

36. std::cout << "Connecte!" << std::endl;

37. std::cout << "Entrez une phrase >";

38. std::string phrase;

39. std::getline(std::cin, phrase);

40. if (!client.send(reinterpret_cast<const unsigned char*>(phrase.c_str()), static_cast<unsigned int>(phrase.length())))

41. {

42. std::cout << "Erreur envoi : " << Network::Errors::Get() << std::endl;

43. break;

44. }

45. }

46. else

47. {

48. std::cout << "Connexion echoue : " << static_cast<int>(connection->result) << std::endl;

49. break;

50. }

51. }

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

53. {

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

55. std::string reply(reinterpret_cast<const char*>(userdata->data.data()), userdata->data.size());

56. std::cout << "Reponse du serveur : " << reply << std::endl;

57. std::cout << ">";

58. std::string phrase;

59. std::getline(std::cin, phrase);

60. if (!client.send(reinterpret_cast<const unsigned char*>(phrase.c_str()), static_cast<unsigned int>(phrase.length())))

61. {

62. std::cout << "Erreur envoi : " << Network::Errors::Get() << std::endl;

63. break;

64. }

65. }

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

67. {

68. auto disconnection = msg->as<Network::Messages::Disconnection>();

69. std::cout << "Deconnecte : " << static_cast<int>(disconnection->reason) << std::endl;

70. break;

71. }

72. }

73. }

74. }

75. Network::Release();

76. return 0;

77. }

Vous pouvez réutiliser le serveur du chapitre 3 qui utilise déjà ce protocole en interne (avec une implémentation très différente) afin de tester ce code.

Le while(1) de la ligne 26 représente la boucle principale du programme, ou votre boucle de gameplay.

Article précédent

<< TCP - Mode non bloquant pour le client

TCP - Un premier serveur : miniserveur >>