mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
53788d5ba5
This should fix a rare crash that happens when the playlists file is reloaded during disconnect. The client fetches the playlists from the server on connect. On disconnect, we want to reload the one from the client so that if the player want's to create his own game, that he would have his own playlists. The fix is to delay the reload of the playlists file to the beginning of the next frame.
326 lines
11 KiB
C++
326 lines
11 KiB
C++
//=============================================================================//
|
|
//
|
|
// Purpose: Netchannel system utilities
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "core/stdafx.h"
|
|
#include "tier0/frametask.h"
|
|
#include "tier1/cvar.h"
|
|
#include "vpc/keyvalues.h"
|
|
#include "common/callback.h"
|
|
#include "engine/net.h"
|
|
#include "engine/net_chan.h"
|
|
#ifndef CLIENT_DLL
|
|
#include "engine/server/server.h"
|
|
#include "engine/client/client.h"
|
|
#include "server/vengineserver_impl.h"
|
|
#endif // !CLIENT_DLL
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel name
|
|
// Output : const char*
|
|
//-----------------------------------------------------------------------------
|
|
const char* CNetChan::GetName(void) const
|
|
{
|
|
return this->m_Name;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel address
|
|
// Output : const char*
|
|
//-----------------------------------------------------------------------------
|
|
const char* CNetChan::GetAddress(bool onlyBase) const
|
|
{
|
|
return this->remote_address.ToString(onlyBase);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel port in host byte order
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNetChan::GetPort(void) const
|
|
{
|
|
return int(ntohs(this->remote_address.GetPort()));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel data rate
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNetChan::GetDataRate(void) const
|
|
{
|
|
return this->m_Rate;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel buffer size (NET_FRAMES_BACKUP)
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNetChan::GetBufferSize(void) const
|
|
{
|
|
return NET_FRAMES_BACKUP;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel latency
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetLatency(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].latency;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel average choke
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetAvgChoke(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].avgchoke;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel average latency
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetAvgLatency(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].avglatency;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel average loss
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetAvgLoss(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].avgloss;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel average packets
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetAvgPackets(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].avgpacketspersec;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel average data
|
|
// Input : flow -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetAvgData(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].avgbytespersec;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel total data
|
|
// Input : flow -
|
|
// Output : int64_t
|
|
//-----------------------------------------------------------------------------
|
|
int64_t CNetChan::GetTotalData(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].totalbytes;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel total packets
|
|
// Input : flow -
|
|
// Output : int64_t
|
|
//-----------------------------------------------------------------------------
|
|
int64_t CNetChan::GetTotalPackets(int flow) const
|
|
{
|
|
return this->m_DataFlow[flow].totalpackets;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel sequence number
|
|
// Input : flow -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNetChan::GetSequenceNr(int flow) const
|
|
{
|
|
if (flow == FLOW_OUTGOING)
|
|
{
|
|
return this->m_nOutSequenceNr;
|
|
}
|
|
else if (flow == FLOW_INCOMING)
|
|
{
|
|
return this->m_nInSequenceNr;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel connect time
|
|
// Output : double
|
|
//-----------------------------------------------------------------------------
|
|
double CNetChan::GetTimeConnected(void) const
|
|
{
|
|
double t = *g_pNetTime - connect_time;
|
|
return (t > 0.0) ? t : 0.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel timeout
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CNetChan::GetTimeoutSeconds(void) const
|
|
{
|
|
return this->m_Timeout;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets the netchannel socket
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNetChan::GetSocket(void) const
|
|
{
|
|
return this->m_Socket;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets a const reference to m_StreamVoice
|
|
//-----------------------------------------------------------------------------
|
|
const bf_write& CNetChan::GetStreamVoice(void) const
|
|
{
|
|
return this->m_StreamVoice;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: gets a const reference to remote_address
|
|
//-----------------------------------------------------------------------------
|
|
const netadr_t& CNetChan::GetRemoteAddress(void) const
|
|
{
|
|
return this->remote_address;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: checks if the reliable stream is overflowed
|
|
// Output : true if overflowed, false otherwise
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetChan::IsOverflowed(void) const
|
|
{
|
|
return this->m_StreamReliable.IsOverflowed();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: clears the netchannel
|
|
//-----------------------------------------------------------------------------
|
|
void CNetChan::Clear(bool bStopProcessing)
|
|
{
|
|
v_NetChan_Clear(this, bStopProcessing);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: shutdown netchannel
|
|
// Input : *this -
|
|
// *szReason -
|
|
// bBadRep -
|
|
// bRemoveNow -
|
|
//-----------------------------------------------------------------------------
|
|
void CNetChan::_Shutdown(CNetChan* pChan, const char* szReason, uint8_t bBadRep, bool bRemoveNow)
|
|
{
|
|
v_NetChan_Shutdown(pChan, szReason, bBadRep, bRemoveNow);
|
|
|
|
#ifndef DEDICATED
|
|
// Delay execution to the next frame; this is required to avoid a rare crash.
|
|
// Cannot reload playlists while still disconnecting.
|
|
g_TaskScheduler->Dispatch([]()
|
|
{
|
|
// Re-load and re-init playlists from the disk to replace the cached one we received from the server.
|
|
_DownloadPlaylists_f();
|
|
KeyValues::InitPlaylists();
|
|
}, 0);
|
|
#endif // !DEDICATED
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: process message
|
|
// Input : *pChan -
|
|
// *pMsg -
|
|
// Output : true on success, false on failure
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetChan::_ProcessMessages(CNetChan* pChan, bf_read* pMsg)
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
if (!ThreadInServerFrameThread() || !net_processTimeBudget->GetInt())
|
|
return v_NetChan_ProcessMessages(pChan, pMsg);
|
|
|
|
const double flStartTime = Plat_FloatTime();
|
|
const bool bResult = v_NetChan_ProcessMessages(pChan, pMsg);
|
|
|
|
if (!pChan->m_MessageHandler) // NetChannel removed?
|
|
return bResult;
|
|
|
|
CClient* pClient = reinterpret_cast<CClient*>(pChan->m_MessageHandler);
|
|
ServerPlayer_t* pSlot = &g_ServerPlayer[pClient->GetUserID()];
|
|
|
|
if (flStartTime - pSlot->m_flLastNetProcessTime >= 1.0 ||
|
|
pSlot->m_flLastNetProcessTime == -1.0)
|
|
{
|
|
pSlot->m_flLastNetProcessTime = flStartTime;
|
|
pSlot->m_flCurrentNetProcessTime = 0.0;
|
|
}
|
|
pSlot->m_flCurrentNetProcessTime +=
|
|
(Plat_FloatTime() * 1000) - (flStartTime * 1000);
|
|
|
|
if (pSlot->m_flCurrentNetProcessTime >
|
|
net_processTimeBudget->GetDouble())
|
|
{
|
|
Warning(eDLL_T::SERVER, "Removing netchannel '%s' ('%s' exceeded frame budget by '%3.1f'ms!)\n",
|
|
pChan->GetName(), pChan->GetAddress(), (pSlot->m_flCurrentNetProcessTime - net_processTimeBudget->GetDouble()));
|
|
pClient->Disconnect(Reputation_t::REP_MARK_BAD, "#DISCONNECT_NETCHAN_OVERFLOW");
|
|
|
|
return false;
|
|
}
|
|
|
|
return bResult;
|
|
#else // !CLIENT_DLL
|
|
return v_NetChan_ProcessMessages(pChan, pMsg);
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets the remote frame times
|
|
// Input : flFrameTime -
|
|
// flFrameTimeStdDeviation -
|
|
//-----------------------------------------------------------------------------
|
|
void CNetChan::SetRemoteFramerate(float flFrameTime, float flFrameTimeStdDeviation)
|
|
{
|
|
m_flRemoteFrameTime = flFrameTime;
|
|
m_flRemoteFrameTimeStdDeviation = flFrameTimeStdDeviation;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets the remote cpu statistics
|
|
// Input : nStats -
|
|
//-----------------------------------------------------------------------------
|
|
void CNetChan::SetRemoteCPUStatistics(uint8_t nStats)
|
|
{
|
|
m_nServerCPU = nStats;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
void VNetChan::Attach() const
|
|
{
|
|
DetourAttach((PVOID*)&v_NetChan_Shutdown, &CNetChan::_Shutdown);
|
|
DetourAttach((PVOID*)&v_NetChan_ProcessMessages, &CNetChan::_ProcessMessages);
|
|
}
|
|
void VNetChan::Detach() const
|
|
{
|
|
DetourDetach((PVOID*)&v_NetChan_Shutdown, &CNetChan::_Shutdown);
|
|
DetourDetach((PVOID*)&v_NetChan_ProcessMessages, &CNetChan::_ProcessMessages);
|
|
}
|