add custom versioning string during handshake

Author: JonathSpirit

includes/FastEngine/network/C_netCommand.hpp

@@ -51,6 +51,8 @@
         1000                                                                                                           \
     }
 
+#define FGE_NET_MAX_VERSIONING_STRING_SIZE 32
+
 namespace fge::net
 {
 
@@ -131,6 +133,9 @@ class FGE_API NetConnectCommand : public NetCommand
     using NetCommand::NetCommand;
     ~NetConnectCommand() final = default;
 
+    void setVersioningString(std::string_view versioningString);
+    [[nodiscard]] std::string const& getVersioningString() const;
+
     [[nodiscard]] NetCommandTypes getType() const override { return NetCommandTypes::CONNECT; }
 
     [[nodiscard]] NetCommandResults update(TransmitPacketPtr& buffPacket,
@@ -159,6 +164,7 @@ class FGE_API NetConnectCommand : public NetCommand
     } g_state{States::TRANSMIT_FGE_HANDSHAKE};
     bool g_mtuTested{false};
     std::future<uint16_t> g_mtuFuture;
+    std::string g_versioningString;
 };
 
 class FGE_API NetDisconnectCommand : public NetCommand

includes/FastEngine/network/C_server.hpp

@@ -195,6 +195,9 @@ class FGE_API ServerSideNetUdp
     ServerSideNetUdp& operator=(ServerSideNetUdp const& r) = delete;
     ServerSideNetUdp& operator=(ServerSideNetUdp&& r) noexcept = delete;
 
+    void setVersioningString(std::string_view versioningString);
+    [[nodiscard]] std::string const& getVersioningString() const;
+
     [[nodiscard]] bool
     start(Port bindPort, IpAddress const& bindIp, IpAddress::Types addressType = IpAddress::Types::None);
     [[nodiscard]] bool start(IpAddress::Types addressType = IpAddress::Types::None);
@@ -267,6 +270,8 @@ class FGE_API ServerSideNetUdp
     bool g_running;
 
     void* g_crypt_ctx;
+
+    std::string g_versioningString;
 };
 
 /**
@@ -298,7 +303,7 @@ class FGE_API ClientSideNetUdp : public NetFluxUdp
     [[nodiscard]] bool isRunning() const;
 
     [[nodiscard]] std::future<uint16_t> retrieveMTU();
-    [[nodiscard]] std::future<bool> connect();
+    [[nodiscard]] std::future<bool> connect(std::string_view versioningString = std::string_view{});
     [[nodiscard]] std::future<void> disconnect();
 
     [[nodiscard]] IpAddress::Types getAddressType() const;

sources/network/C_netCommand.cpp

@@ -197,6 +197,20 @@ NetCommandResults NetMTUCommand::onReceive(std::unique_ptr<ProtocolPacket>& pack
     return NetCommandResults::WORKING;
 }
 
+void NetConnectCommand::setVersioningString(std::string_view versioningString)
+{
+    if (versioningString.size() > FGE_NET_MAX_VERSIONING_STRING_SIZE)
+    {
+        throw Exception("Versioning string too long");
+    }
+
+    this->g_versioningString = versioningString;
+}
+std::string const& NetConnectCommand::getVersioningString() const
+{
+    return this->g_versioningString;
+}
+
 NetCommandResults NetConnectCommand::update(TransmitPacketPtr& buffPacket,
                                             [[maybe_unused]] IpAddress::Types addressType,
                                             Client& client,
@@ -213,7 +227,8 @@ NetCommandResults NetConnectCommand::update(TransmitPacketPtr& buffPacket,
         client._mtuFinalizedFlag = false;
 
         buffPacket = CreatePacket(NET_INTERNAL_ID_FGE_HANDSHAKE);
-        buffPacket->doNotDiscard().doNotReorder().doNotFragment() << FGE_NET_HANDSHAKE_STRING;
+        buffPacket->doNotDiscard().doNotReorder().doNotFragment()
+                << FGE_NET_HANDSHAKE_STRING << this->g_versioningString;
         this->_g_timeout = std::chrono::milliseconds::zero();
         this->g_state = States::WAITING_FGE_HANDSHAKE;
         break;

sources/network/C_server.cpp

@@ -232,6 +232,7 @@ void ServerNetFluxUdp::processClients()
         this->g_commandsUpdateTick = std::chrono::milliseconds::zero();
     }
 }
+
 FluxProcessResults
 ServerNetFluxUdp::process(ClientSharedPtr& refClient, ReceivedPacketPtr& packet, bool allowUnknownClient)
 {
@@ -466,10 +467,15 @@ FluxProcessResults ServerNetFluxUdp::processUnknownClient(ClientSharedPtr& refCl
 
         using namespace fge::net::rules;
         std::string handshakeString;
+        std::string versioningString;
         auto const err = RValid(RSizeMustEqual<std::string>(sizeof(FGE_NET_HANDSHAKE_STRING) - 1,
                                                             {packet->packet(), &handshakeString}))
-                                 .end();
-        if (err || !packet->endReached() || handshakeString != FGE_NET_HANDSHAKE_STRING)
+                                 .and_then([&](auto& chain) {
+            return RValid(RSizeRange<std::string>(0, FGE_NET_MAX_VERSIONING_STRING_SIZE,
+                                                  chain.template newChain<std::string>(&versioningString)));
+        }).end();
+        if (err || !packet->endReached() || handshakeString != FGE_NET_HANDSHAKE_STRING ||
+            versioningString != this->g_server->getVersioningString())
         { //TODO: endReached() check should be done in .end() method
             std::cout << "Handshake failed" << std::endl;
             return FluxProcessResults::NOT_RETRIEVABLE;
@@ -713,6 +719,16 @@ ServerSideNetUdp::~ServerSideNetUdp()
     this->stop();
 }
 
+void ServerSideNetUdp::setVersioningString(std::string_view versioningString)
+{
+    std::scoped_lock const lock{this->g_mutexServer};
+    this->g_versioningString = versioningString;
+}
+std::string const& ServerSideNetUdp::getVersioningString() const
+{
+    return this->g_versioningString;
+}
+
 bool ServerSideNetUdp::start(Port bindPort, IpAddress const& bindIp, IpAddress::Types addressType)
 {
     if (this->g_running)
@@ -1238,7 +1254,7 @@ std::future<uint16_t> ClientSideNetUdp::retrieveMTU()
 
     return future;
 }
-std::future<bool> ClientSideNetUdp::connect()
+std::future<bool> ClientSideNetUdp::connect(std::string_view versioningString)
 {
     if (!this->g_running)
     {
@@ -1247,6 +1263,7 @@ std::future<bool> ClientSideNetUdp::connect()
 
     auto command = std::make_unique<NetConnectCommand>(&this->g_commands);
     auto future = command->get_future();
+    command->setVersioningString(versioningString);
 
     std::scoped_lock const lock(this->g_mutexCommands);
     this->g_commands.push_back(std::move(command));