console: server->client convar replication using setr command

Author: blattersturm

code/client/citicore/console/Console.Variables.cpp

@@ -55,6 +55,11 @@ ConsoleVariableManager::ConsoleVariableManager(console::Context* parentContext)
 		setCommand(ConVar_ServerInfo, variable, value);
 	});
 #endif
+
+	// set replicated
+	m_setrCommand = std::make_unique<ConsoleCommand>(m_parentContext, "setr", [=](const std::string& variable, const std::string& value) {
+		setCommand(ConVar_Replicated, variable, value);
+	});
 }
 
 ConsoleVariableManager::~ConsoleVariableManager()
@@ -127,6 +132,20 @@ void ConsoleVariableManager::RemoveEntryFlags(const std::string& name, int flags
 	}
 }
 
+int ConsoleVariableManager::GetEntryFlags(const std::string& name)
+{
+	std::unique_lock<std::shared_mutex> lock(m_mutex);
+
+	auto it = m_entries.find(name);
+
+	if (it != m_entries.end())
+	{
+		return it->second.flags;
+	}
+
+	return 0;
+}
+
 void ConsoleVariableManager::ForAllVariables(const TVariableCB& callback, int flagMask)
 {
 	// store first so we don't have to deal with recursive locks
@@ -152,6 +171,29 @@ void ConsoleVariableManager::ForAllVariables(const TVariableCB& callback, int fl
 	}
 }
 
+void ConsoleVariableManager::RemoveVariablesWithFlag(int flagMask)
+{
+	std::vector<int> iterationList;
+
+	{
+		std::unique_lock<std::shared_mutex> lock(m_mutex);
+
+		for (auto& entry : m_entries)
+		{
+			// if flags match the mask
+			if ((entry.second.flags & flagMask) != 0)
+			{
+				iterationList.push_back(entry.second.token);
+			}
+		}
+	}
+
+	for (auto token : iterationList)
+	{
+		Unregister(token);
+	}
+}
+
 void ConsoleVariableManager::SaveConfiguration(const TWriteLineCB& writeLineFunction)
 {
 	ForAllVariables([&](const std::string& name, int flags, const THandlerPtr& variable) {

code/client/citicore/console/Console.Variables.h

@@ -3,6 +3,8 @@
 #include "Console.CommandHelpers.h"
 #include "Console.Commands.h"
 
+#include <se/Security.h>
+
 namespace internal
 {
 class ConsoleVariableEntryBase
@@ -50,6 +52,7 @@ enum ConsoleVariableFlags
 	ConVar_Archive    = 0x1,
 	ConVar_Modified   = 0x2,
 	ConVar_ServerInfo = 0x4,
+	ConVar_Replicated = 0x8,
 };
 
 class ConsoleVariableManager
@@ -78,8 +81,12 @@ class ConsoleVariableManager
 
 	virtual void RemoveEntryFlags(const std::string& name, int flags);
 
+	virtual int GetEntryFlags(const std::string& name);
+
 	virtual void ForAllVariables(const TVariableCB& callback, int flagMask = 0xFFFFFFFF);
 
+	virtual void RemoveVariablesWithFlag(int flags);
+
 	virtual void SaveConfiguration(const TWriteLineCB& writeLineFunction);
 
 	inline console::Context* GetParentContext()
@@ -116,6 +123,7 @@ class ConsoleVariableManager
 	std::unique_ptr<ConsoleCommand> m_setCommand;
 	std::unique_ptr<ConsoleCommand> m_setaCommand;
 	std::unique_ptr<ConsoleCommand> m_setsCommand;
+	std::unique_ptr<ConsoleCommand> m_setrCommand;
 
 	std::unique_ptr<ConsoleCommand> m_toggleCommand;
 	std::unique_ptr<ConsoleCommand> m_vstrCommand;
@@ -208,6 +216,17 @@ class ConsoleVariableEntry : public ConsoleVariableEntryBase
 			return false;
 		}
 
+#ifndef IS_FXSERVER
+		if (m_manager->GetEntryFlags(m_name) & ConVar_Replicated)
+		{
+			if (!seCheckPrivilege("builtin.setReplicated"))
+			{
+				console::Printf("cmd", "Cannot set server-replicated ConVar %s from client console.\n", m_name);
+				return false;
+			}
+		}
+#endif
+
 		// update modified flags if changed
 		if (!typename ConsoleArgumentTraits<T>::Equal()(m_curValue, newValue))
 		{

code/components/citizen-server-impl/include/ClientRegistry.h

@@ -160,6 +160,8 @@ namespace fx
 
 		fwEvent<Client*> OnClientCreated;
 
+		fwEvent<Client*> OnConnectedClient;
+
 	private:
 		uint16_t m_hostNetId;
 

code/components/citizen-server-impl/src/ClientRegistry.cpp

@@ -91,6 +91,9 @@ namespace fx
 		{
 			events->TriggerClientEvent("onPlayerJoining", target, otherClient->GetNetId(), otherClient->GetName(), otherClient->GetSlotId());
 		});
+
+		// trigger connection handlers
+		OnConnectedClient(client.get());
 	}
 
 	std::shared_ptr<fx::Client> ClientRegistry::GetHost()

code/components/citizen-server-impl/src/ServerConsoleReplication.cpp

@@ -0,0 +1,69 @@
+#include <StdInc.h>
+
+#include <CoreConsole.h>
+
+#include <ClientRegistry.h>
+#include <GameServer.h>
+
+#include <ServerInstanceBase.h>
+
+#include <msgpack.hpp>
+
+static InitFunction initFunction([]()
+{
+	fx::ServerInstanceBase::OnServerCreate.Connect([](fx::ServerInstanceBase* instance)
+	{
+		auto console = instance->GetComponent<console::Context>();
+		auto gameServer = instance->GetComponent<fx::GameServer>().GetRef();
+		auto clientRegistry = instance->GetComponent<fx::ClientRegistry>().GetRef();
+
+		auto sendVariableList = [](fx::Client* client, const std::map<std::string, std::string>& list)
+		{
+			msgpack::sbuffer buf;
+			msgpack::packer<msgpack::sbuffer> packer(buf);
+
+			packer.pack(list);
+
+			// build the target event
+			net::Buffer outBuffer;
+			outBuffer.Write(HashRageString("msgConVars"));
+
+			// payload
+			outBuffer.Write(buf.data(), buf.size());
+
+			client->SendPacket(0, outBuffer, ENET_PACKET_FLAG_RELIABLE);
+		};
+
+		clientRegistry->OnConnectedClient.Connect([console, sendVariableList](fx::Client* client)
+		{
+			std::map<std::string, std::string> variableList;
+			
+			console->GetVariableManager()->ForAllVariables([&variableList](const std::string& name, int flags, const std::shared_ptr<internal::ConsoleVariableEntryBase>& var)
+			{
+				variableList.emplace(name, var->GetValue());
+			}, ConVar_Replicated);
+
+			sendVariableList(client, variableList);
+		});
+
+		gameServer->OnTick.Connect([=]()
+		{
+			std::map<std::string, std::string> variableList;
+
+			console->GetVariableManager()->ForAllVariables([console, &variableList](const std::string& name, int flags, const std::shared_ptr<internal::ConsoleVariableEntryBase>& var)
+			{
+				variableList.emplace(name, var->GetValue());
+
+				console->GetVariableManager()->RemoveEntryFlags(name, ConVar_Modified);
+			}, ConVar_Replicated | ConVar_Modified);
+
+			if (!variableList.empty())
+			{
+				clientRegistry->ForAllClients([&variableList, sendVariableList](const std::shared_ptr<fx::Client>& client)
+				{
+					sendVariableList(client.get(), variableList);
+				});
+			}
+		});
+	}, 999999);
+});

code/components/glue/component.json

@@ -8,7 +8,8 @@
 		"gta:core",
 		"conhost",
 		"vendor:cpp-uri",
-		"vendor:nng"
+		"vendor:nng",
+		"vendor:msgpack-c"
 	],
 	"provides": []
 }

code/components/glue/src/BindNetLibrary.cpp

@@ -12,9 +12,16 @@
 #include <GameInit.h>
 #include <nutsnbolts.h>
 
+#include <msgpack.hpp>
+
+#include <CoreConsole.h>
+#include <se/Security.h>
+
 #ifdef GTA_FIVE
 static InitFunction initFunction([] ()
 {
+	seGetCurrentContext()->AddAccessControlEntry(se::Principal{ "system.internal" }, se::Object{ "builtin" }, se::AccessType::Allow);
+
 	NetLibrary::OnNetLibraryCreate.Connect([] (NetLibrary* library)
 	{
 		static NetLibrary* netLibrary = library;
@@ -54,7 +61,24 @@ static InitFunction initFunction([] ()
 		OnKillNetworkDone.Connect([=]()
 		{
 			library->FinalizeDisconnect();
+
+			console::GetDefaultContext()->GetVariableManager()->RemoveVariablesWithFlag(ConVar_Replicated);
 		});
+
+		library->AddReliableHandler("msgConVars", [](const char* buf, size_t len)
+		{
+			auto unpacked = msgpack::unpack(buf, len);
+			auto conVars = unpacked.get().as<std::map<std::string, std::string>>();
+
+			se::ScopedPrincipal principalScope(se::Principal{ "system.console" });
+			se::ScopedPrincipal principalScopeInternal(se::Principal{ "system.internal" });
+
+			// set variable
+			for (const auto& conVar : conVars)
+			{
+				console::GetDefaultContext()->ExecuteSingleCommandDirect(ProgramArguments{ "setr", conVar.first, conVar.second });
+			}
+		}, true);
 	});
 
 	Instance<ICoreGameInit>::Get()->OnGameRequestLoad.Connect([]()