gameserver: apply networking limit increases

Author: RaphaelIT7

source/lua.h

@@ -35,7 +35,7 @@ namespace Lua
 
 	// Each new metatable has this entry.
 	struct LuaMetaEntry {
-		unsigned char iType = -1;
+		unsigned char iType = UCHAR_MAX;
 	};
 
 	/*

source/modules/gameserver.cpp

@@ -1333,6 +1333,23 @@ LUA_FUNCTION_STATIC(CNetChan_SetTimeout)
 	return 0;
 }
 
+LUA_FUNCTION_STATIC(CNetChan_GetRate)
+{
+	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
+
+	LUA->PushNumber(pNetChannel->GetDataRate());
+	return 1;
+}
+
+LUA_FUNCTION_STATIC(CNetChan_SetRate)
+{
+	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
+	float rate = (float)LUA->CheckNumber(2);
+
+	pNetChannel->SetDataRate(rate);
+	return 0;
+}
+
 LUA_FUNCTION_STATIC(CNetChan_Transmit)
 {
 	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
@@ -1390,6 +1407,15 @@ LUA_FUNCTION_STATIC(CNetChan_Shutdown)
 	return 0;
 }
 
+LUA_FUNCTION_STATIC(CNetChan_CanPacket)
+{
+	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
+
+	net_time = Util::engineserver->Time();
+	LUA->PushBool(pNetChannel->CanPacket());
+	return 1;
+}
+
 static Detouring::Hook detour_CNetChan_D2;
 void hook_CNetChan_D2(CNetChan* pNetChan)
 {
@@ -1654,6 +1680,16 @@ LUA_FUNCTION_STATIC(CNetChan_SendMessage)
 	return 1;
 }
 
+LUA_FUNCTION_STATIC(CNetChan_SendFile)
+{
+	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
+	const char* pFileName = LUA->CheckString(2);
+	int transferID = LUA->CheckNumber(3);
+
+	LUA->PushBool(pNetChannel->SendFile(pFileName, transferID));
+	return 1;
+}
+
 LUA_FUNCTION_STATIC(CNetChan_SetMessageCallback)
 {
 	CNetChan* pNetChannel = Get_CNetChan(LUA, 1, true);
@@ -2269,12 +2305,16 @@ void CGameServerModule::LuaInit(GarrysMod::Lua::ILuaInterface* pLua, bool bServe
 		Util::AddFunc(pLua, CNetChan_GetClearTime, "GetClearTime");
 		Util::AddFunc(pLua, CNetChan_GetTimeout, "GetTimeout");
 		Util::AddFunc(pLua, CNetChan_SetTimeout, "SetTimeout");
+		Util::AddFunc(pLua, CNetChan_GetRate, "GetRate");
+		Util::AddFunc(pLua, CNetChan_SetRate, "SetRate");
 		Util::AddFunc(pLua, CNetChan_Transmit, "Transmit");
 		Util::AddFunc(pLua, CNetChan_ProcessStream, "ProcessStream");
 		Util::AddFunc(pLua, CNetChan_SetMaxBufferSize, "SetMaxBufferSize");
 		Util::AddFunc(pLua, CNetChan_GetMaxRoutablePayloadSize, "GetMaxRoutablePayloadSize");
 		Util::AddFunc(pLua, CNetChan_SendMessage, "SendMessage");
+		Util::AddFunc(pLua, CNetChan_SendFile, "SendFile");
 		Util::AddFunc(pLua, CNetChan_Shutdown, "Shutdown");
+		Util::AddFunc(pLua, CNetChan_CanPacket, "CanPacket");
 
 		// Callbacks
 		Util::AddFunc(pLua, CNetChan_SetMessageCallback, "SetMessageCallback");
@@ -2874,6 +2914,32 @@ int NET_ReceiveStream(int nSock, char* buf, int len, int flags)
 	return func_NET_ReceiveStream(nSock, buf, len, flags);
 }
 
+static ConVar* host_timescale = nullptr;
+static Detouring::Hook detour_NET_SetTime;
+static void hook_NET_SetTime(double flRealtime) // We need this hook to keep net_time up to date
+{
+	detour_NET_SetTime.GetTrampoline<Symbols::NET_SetTime>()(flRealtime);
+
+	static double s_last_realtime = 0;
+
+	double frametime = flRealtime - s_last_realtime;
+	s_last_realtime = flRealtime;
+
+	if (frametime > 1.0f)
+	{
+		// if we have very long frame times because of loading stuff
+		// don't apply that to net time to avoid unwanted timeouts
+		frametime = 1.0f;
+	}
+	else if (frametime < 0.0f)
+	{
+		frametime = 0.0f;
+	}
+
+	// adjust network time so fakelag works with host_timescale
+	net_time += frametime * (host_timescale ? host_timescale->GetFloat() : 1.0f);
+}
+
 void CGameServerModule::InitDetour(bool bPreServer)
 {
 	if (bPreServer)
@@ -2916,6 +2982,12 @@ void CGameServerModule::InitDetour(bool bPreServer)
 		(void*)hook_CGameClient_SpawnPlayer, m_pID
 	);
 
+	Detour::Create(
+		&detour_NET_SetTime, "NET_SetTime",
+		engine_loader.GetModule(), Symbols::NET_SetTimeSym,
+		(void*)hook_NET_SetTime, m_pID
+	);
+
 	SourceSDK::FactoryLoader server_loader("server");
 	if (!g_pModuleManager.IsMarkedAsBinaryModule()) // Loaded by require? Then we skip this.
 	{
@@ -2989,4 +3061,6 @@ void CGameServerModule::InitDetour(bool bPreServer)
 	Detour::CheckFunction((void*)func_NET_ReceiveStream, "NET_ReceiveStream");
 
 	s_NetChannels = Detour::ResolveSymbol<CUtlVectorMT<CUtlVector<CNetChan*>>>(engine_loader, Symbols::s_NetChannelsSym);
+
+	host_timescale = g_pCVar->FindVar("host_timescale");
 }

source/sourcesdk/cnetchan.cpp

@@ -16,6 +16,7 @@
 #include "filesystem_init.h"
 #include "custom_net_chan.h"
 #include <lz4/lz4_compression.h>
+#include <memory>
 
 // memdbgon must be the last include file in a .cpp file!!!
 #include "tier0/memdbgon.h"
@@ -36,7 +37,7 @@ static ConVar net_blockmsg( "holylib_net_blockmsg", "none", FCVAR_CHEAT, "Discar
 static ConVar net_showdrop( "holylib_net_showdrop", "0", 0, "Show dropped packets in console" );
 static ConVar net_drawslider( "holylib_net_drawslider", "0", 0, "Draw completion slider during signon" );
 static ConVar net_chokeloopback( "holylib_net_chokeloop", "0", 0, "Apply bandwidth choke to loopback packets" );
-static ConVar net_maxfilesize( "holylib_net_maxfilesize", "256", 0, "Maximum allowed file size for uploading in MiB", true, 0, true, 512 );
+static ConVar net_maxfilesize( "holylib_net_maxfilesize", "4096", 0, "Maximum allowed file size for uploading in MiB", true, 0, true, 4096 );
 static ConVar net_compresspackets( "holylib_net_compresspackets", "1", 0, "Use compression on game packets." );
 static ConVar net_compresspackets_minsize( "holylib_net_compresspackets_minsize", "1024", 0, "Don't bother compressing packets below this size." );
 static ConVar net_maxcleartime( "holylib_net_maxcleartime", "4.0", 0, "Max # of seconds we can wait for next packets to be sent based on rate setting (0 == no limit)." );
@@ -1145,10 +1146,10 @@ bool CNetChan::CreateFragmentsFromFile( const char *filename, int stream, unsign
 	}
 
 	int totalBytes = (int)g_pFullFileSystem->Size( filename, pPathID );
-
-	if ( totalBytes >= (net_maxfilesize.GetInt()*1024*1024) )
+	
+	if ( totalBytes >= (((uint64_t)net_maxfilesize.GetInt()) *1024*1024) ) // We need it as a uint64_t since else we'll overflow the int!
 	{
-		ConMsg( "CreateFragmentsFromFile: '%s' size exceeds net_maxfilesize limit (%i MiB).\n", filename, net_maxfilesize.GetInt() );
+		ConMsg( "CreateFragmentsFromFile: '%s' size exceeds net_maxfilesize limit (%i MiB, %i).\n", filename, net_maxfilesize.GetInt(), totalBytes);
 		return false;
 	}
 
@@ -1620,7 +1621,9 @@ A 0 length will still generate a packet and deal with the reliable messages.
 */
 int CNetChan::SendDatagram(bf_write *datagram)
 {
-	ALIGN4 byte		send_buf[ NET_MAX_MESSAGE ] ALIGN4_POST;
+	// We cannot stackallocate this amount as else we can easily crash!
+	// We also use static so that each thread only allocates this once instead of on every call & we use a std::unique_ptr so that our memory is freed when the thread dies.
+	static thread_local std::unique_ptr<byte[]> send_buf(new byte[NET_MAX_MESSAGE]);
 
 #ifndef NO_VCR
 	if ( vcr_verbose.GetInt() && datagram && datagram->GetNumBytesWritten() > 0 )
@@ -1664,7 +1667,7 @@ int CNetChan::SendDatagram(bf_write *datagram)
 		m_StreamReliable.Reset();
 	}
 
-	bf_write send( "CNetChan_TransmitBits->send", send_buf, sizeof(send_buf) );
+	bf_write send( "CNetChan_TransmitBits->send", send_buf.get(), NET_MAX_MESSAGE);
 
 	// Prepare the packet header
 	// build packet flags
@@ -3173,6 +3176,7 @@ int CNetChan::IncrementSplitPacketSequence()
 	return ++m_nSplitPacketSequence;
 }
 
+// ToDo: iirc gmod changed this from a blacklist to whitelist for files.
 bool CNetChan::IsValidFileForTransfer( const char *pszFilename )
 {
 	if ( !pszFilename || !pszFilename[ 0 ] )

source/sourcesdk/custom_net_chan.h

@@ -21,11 +21,38 @@
 #include "const.h"
 #include "inetchannel.h"
 
+// Flow control bytes per second limits
+#undef MAX_RATE
+#undef MIN_RATE
+#undef DEFAULT_RATE
+#define MAX_RATE		(1024*1024*16)				
+#define MIN_RATE		4000
+#define DEFAULT_RATE	240000
+
+#undef FRAGMENT_BITS
+#undef FRAGMENT_SIZE
+#undef MAX_FILE_SIZE_BITS
+#undef MAX_FILE_SIZE
+#define FRAGMENT_BITS		13
+constexpr int FRAGMENT_SIZE = 1 << FRAGMENT_BITS;
+#define MAX_FILE_SIZE_BITS	29
+constexpr int MAX_FILE_SIZE = (1 << MAX_FILE_SIZE_BITS) - 1;	// maximum transferable size is	4GB
+
+#undef NET_MAX_PAYLOAD
+#undef NET_MAX_DATAGRAM_PAYLOAD
+// This is the packet payload without any header bytes (which are attached for actual sending)
+#define	NET_MAX_PAYLOAD				576000	// largest message we can send in bytes
+#define NET_MAX_DATAGRAM_PAYLOAD	8000	// = maximum unreliable payload size
+
 #define MAX_FRAGMENTS_BITS	5	// How many fragments we can send at once
-#define MAX_FRAGMENTS	(1 << MAX_FRAGMENTS_BITS) - 1  // Maximum number of fragments we can safely transmit. -1 as else we would go over MAX_FRAGMENTS_BITS
+constexpr int MAX_FRAGMENTS = (1 << MAX_FRAGMENTS_BITS) - 1;  // Maximum number of fragments we can safely transmit. -1 as else we would go over MAX_FRAGMENTS_BITS
 
 #undef MAX_ROUTABLE_PAYLOAD
-#define MAX_ROUTABLE_PAYLOAD		(FRAGMENT_SIZE * FRAGMENT_SIZE)	// Matches x360 size(1260). Update: Won't match anymore
+constexpr int MAX_ROUTABLE_PAYLOAD = FRAGMENT_SIZE * FRAGMENT_SIZE;	// Matches x360 size(1260). Update: Won't match anymore
+
+
+#undef NET_MAX_MESSAGE
+constexpr int NET_MAX_MESSAGE = PAD_NUMBER((NET_MAX_PAYLOAD + HEADER_BYTES), 16);
 
 // How fast to converge flow estimates
 #define FLOW_AVG ( 3.0F / 4.0F )
@@ -34,10 +61,10 @@
 
 
 #define NET_FRAMES_BACKUP	64	// must be power of 2
-#define NET_FRAMES_MASK		(NET_FRAMES_BACKUP-1)
+constexpr int NET_FRAMES_MASK = (NET_FRAMES_BACKUP - 1);
 
 #define SUBCHANNEL_BITS		4	// raising it above 5 would require changes to m_nOutReliableState & m_nInReliableState as they couldn't hold the states anymore.
-#define MAX_SUBCHANNELS		(1 << SUBCHANNEL_BITS) // we have 16 alternative send&wait bits
+constexpr int MAX_SUBCHANNELS = (1 << SUBCHANNEL_BITS); // we have 16 alternative send&wait bits
 
 #define SUBCHANNEL_FREE		0	// subchannel is free to use
 #define SUBCHANNEL_TOSEND	1	// subchannel has data, but not send yet

source/symbols.cpp

@@ -890,4 +890,8 @@ namespace Symbols
 	const std::vector<Symbol> s_NetChannelsSym = {
 		Symbol::FromName("_ZL13s_NetChannels"),
 	};
+
+	const std::vector<Symbol> NET_SetTimeSym = {
+		Symbol::FromName("_Z11NET_SetTimed"),
+	};
 }

source/symbols.h

@@ -628,6 +628,9 @@ namespace Symbols
 	typedef int (*NET_ReceiveStream)(int nSock, char * buf, int len, int flags);
 	extern const std::vector<Symbol> NET_ReceiveStreamSym;
 
+	typedef void (*NET_SetTime)(double flRealtime);
+	extern const std::vector<Symbol> NET_SetTimeSym;
+
 	extern const std::vector<Symbol> s_NetChannelsSym;
 
 	//---------------------------------------------------------------------------------

source/util.h

@@ -456,7 +456,7 @@ struct LuaUserData;
 extern std::unordered_set<LuaUserData*> g_pLuaUserData; // A set containing all LuaUserData that actually hold a reference.
 #endif
 struct LuaUserData { // No constructor/deconstructor since its managed by Lua!
-	inline void Init(GarrysMod::Lua::ILuaInterface* LUA, int type, void* pData)
+	inline void Init(GarrysMod::Lua::ILuaInterface* LUA, unsigned char type, void* pData)
 	{
 		// Since Lua creates our userdata, we need to set all the fields ourself!
 #if HOLYLIB_UTIL_BASEUSERDATA