R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Adjust names

Browse Source 
Adjust since previously they were pointers but now references.
This commit is contained in:
Kawe Mazidjatari 2023-08-04 17:41:55 +02:00
parent bb5e92a563
commit d7f92cbefd
4 changed files with 71 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
r5dev/engine/server/sv_rcon.cpp
View File

@ -97,8 +97,8 @@ void CRConServer::Think(void)
const netadr_t& netAdr = m_Socket.GetAcceptedSocketAddress(m_nConnIndex);
if (!m_WhiteListAddress.CompareAdr(netAdr))
{
const CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(m_nConnIndex);
if (!pData.m_bAuthorized)
const CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(m_nConnIndex);
if (!data.m_bAuthorized)
{
Disconnect("redundant");
}
@ -169,18 +169,18 @@ void CRConServer::RunFrame(void)
const int nCount = m_Socket.GetAcceptedSocketCount();
for (m_nConnIndex = nCount - 1; m_nConnIndex >= 0; m_nConnIndex--)
{
CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(m_nConnIndex);
CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(m_nConnIndex);
if (CheckForBan(pData))
if (CheckForBan(data))
{
SendEncode(pData.m_hSocket, s_BannedMessage, "",
SendEncode(data.m_hSocket, s_BannedMessage, "",
sv_rcon::response_t::SERVERDATA_RESPONSE_AUTH, int(eDLL_T::NETCON));
Disconnect("banned");
continue;
}
Recv(pData, sv_rcon_maxpacketsize->GetInt());
Recv(data, sv_rcon_maxpacketsize->GetInt());
}
}
}
@ -204,11 +204,11 @@ bool CRConServer::SendToAll(const char* pMsgBuf, const int nMsgLen) const
const int nCount = m_Socket.GetAcceptedSocketCount();
for (int i = nCount - 1; i >= 0; i--)
{
const CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(i);
const CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(i);
if (pData.m_bAuthorized && !pData.m_bInputOnly)
if (data.m_bAuthorized && !data.m_bInputOnly)
{
int ret = ::send(pData.m_hSocket, sendbuf.str().data(),
int ret = ::send(data.m_hSocket, sendbuf.str().data(),
int(sendbuf.str().size()), MSG_NOSIGNAL);
if (ret == SOCKET_ERROR)
@ -315,11 +315,11 @@ bool CRConServer::Serialize(vector<char>& vecBuf, const char* pResponseMsg, cons
//-----------------------------------------------------------------------------
// Purpose: authenticate new connections
// Input : &request -
// *pData -
// &data -
//-----------------------------------------------------------------------------
void CRConServer::Authenticate(const cl_rcon::request& request, CConnectedNetConsoleData& pData)
void CRConServer::Authenticate(const cl_rcon::request& request, CConnectedNetConsoleData& data)
{
if (pData.m_bAuthorized)
if (data.m_bAuthorized)
{
return;
}
@ -327,16 +327,16 @@ void CRConServer::Authenticate(const cl_rcon::request& request, CConnectedNetCon
{
if (Comparator(request.requestmsg()))
{
pData.m_bAuthorized = true;
data.m_bAuthorized = true;
if (++m_nAuthConnections >= sv_rcon_maxconnections->GetInt())
{
m_Socket.CloseListenSocket();
CloseNonAuthConnection();
}
const char* pSendLogs = (!sv_rcon_sendlogs->GetBool() || pData.m_bInputOnly) ? "0" : "1";
const char* pSendLogs = (!sv_rcon_sendlogs->GetBool() || data.m_bInputOnly) ? "0" : "1";
SendEncode(pData.m_hSocket, s_AuthMessage, pSendLogs,
SendEncode(data.m_hSocket, s_AuthMessage, pSendLogs,
sv_rcon::response_t::SERVERDATA_RESPONSE_AUTH, static_cast<int>(eDLL_T::NETCON));
}
else // Bad password.
@ -347,12 +347,12 @@ void CRConServer::Authenticate(const cl_rcon::request& request, CConnectedNetCon
DevMsg(eDLL_T::SERVER, "Bad RCON password attempt from '%s'\n", netAdr.ToString());
}
SendEncode(pData.m_hSocket, s_WrongPwMessage, "",
SendEncode(data.m_hSocket, s_WrongPwMessage, "",
sv_rcon::response_t::SERVERDATA_RESPONSE_AUTH, static_cast<int>(eDLL_T::NETCON));
pData.m_bAuthorized = false;
pData.m_bValidated = false;
pData.m_nFailedAttempts++;
data.m_bAuthorized = false;
data.m_bValidated = false;
data.m_nFailedAttempts++;
}
}
}
@ -387,7 +387,7 @@ bool CRConServer::Comparator(const string& svPassword) const
//-----------------------------------------------------------------------------
bool CRConServer::ProcessMessage(const char* pMsgBuf, const int nMsgLen)
{
CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(m_nConnIndex);
CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(m_nConnIndex);
cl_rcon::request request;
if (!Decode(&request, pMsgBuf, nMsgLen))
@ -396,27 +396,27 @@ bool CRConServer::ProcessMessage(const char* pMsgBuf, const int nMsgLen)
return false;
}
if (!pData.m_bAuthorized &&
if (!data.m_bAuthorized &&
request.requesttype() != cl_rcon::request_t::SERVERDATA_REQUEST_AUTH)
{
// Notify netconsole that authentication is required.
SendEncode(pData.m_hSocket, s_NoAuthMessage, "",
SendEncode(data.m_hSocket, s_NoAuthMessage, "",
sv_rcon::response_t::SERVERDATA_RESPONSE_AUTH, static_cast<int>(eDLL_T::NETCON));
pData.m_bValidated = false;
pData.m_nIgnoredMessage++;
data.m_bValidated = false;
data.m_nIgnoredMessage++;
return true;
}
switch (request.requesttype())
{
case cl_rcon::request_t::SERVERDATA_REQUEST_AUTH:
{
Authenticate(request, pData);
Authenticate(request, data);
break;
}
case cl_rcon::request_t::SERVERDATA_REQUEST_EXECCOMMAND:
{
if (pData.m_bAuthorized) // Only execute if auth was successful.
if (data.m_bAuthorized) // Only execute if auth was successful.
{
Execute(request);
}
@ -424,10 +424,10 @@ bool CRConServer::ProcessMessage(const char* pMsgBuf, const int nMsgLen)
}
case cl_rcon::request_t::SERVERDATA_REQUEST_SEND_CONSOLE_LOG:
{
if (pData.m_bAuthorized)
if (data.m_bAuthorized)
{
// "0" means the netconsole is input only.
pData.m_bInputOnly = !atoi(request.requestval().c_str());
data.m_bInputOnly = !atoi(request.requestval().c_str());
}
break;
}
@ -474,11 +474,11 @@ void CRConServer::Execute(const cl_rcon::request& request) const
//-----------------------------------------------------------------------------
// Purpose: checks for amount of failed attempts and bans netconsole accordingly
// Input : *pData -
// Input : &data -
//-----------------------------------------------------------------------------
bool CRConServer::CheckForBan(CConnectedNetConsoleData& pData)
bool CRConServer::CheckForBan(CConnectedNetConsoleData& data)
{
if (pData.m_bValidated)
if (data.m_bValidated)
{
return false;
}
@ -509,7 +509,7 @@ bool CRConServer::CheckForBan(CConnectedNetConsoleData& pData)
}
}
pData.m_bValidated = true;
data.m_bValidated = true;
// Check if IP is in the banned list.
if (m_BannedList.find(szNetAdr) != m_BannedList.end())
@ -518,14 +518,14 @@ bool CRConServer::CheckForBan(CConnectedNetConsoleData& pData)
}
// Check if netconsole has reached maximum number of attempts > add to banned list.
if (pData.m_nFailedAttempts >= sv_rcon_maxfailures->GetInt()
|| pData.m_nIgnoredMessage >= sv_rcon_maxignores->GetInt())
if (data.m_nFailedAttempts >= sv_rcon_maxfailures->GetInt()
|| data.m_nIgnoredMessage >= sv_rcon_maxignores->GetInt())
{
// Don't add white listed address to banned list.
if (m_WhiteListAddress.CompareAdr(netAdr))
{
pData.m_nFailedAttempts = 0;
pData.m_nIgnoredMessage = 0;
data.m_nFailedAttempts = 0;
data.m_nIgnoredMessage = 0;
return false;
}
@ -551,8 +551,8 @@ void CRConServer::Disconnect(const char* szReason) // NETMGR
//-----------------------------------------------------------------------------
void CRConServer::Disconnect(const int nIndex, const char* szReason) // NETMGR
{
CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(nIndex);
if (pData.m_bAuthorized || sv_rcon_debug->GetBool())
CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(nIndex);
if (data.m_bAuthorized || sv_rcon_debug->GetBool())
{
// Inform server owner when authenticated connection has been closed.
netadr_t netAdr = m_Socket.GetAcceptedSocketAddress(nIndex);
@ -576,9 +576,9 @@ void CRConServer::CloseNonAuthConnection(void)
int nCount = m_Socket.GetAcceptedSocketCount();
for (int i = nCount - 1; i >= 0; i--)
{
CConnectedNetConsoleData& pData = m_Socket.GetAcceptedSocketData(i);
CConnectedNetConsoleData& data = m_Socket.GetAcceptedSocketData(i);
if (!pData.m_bAuthorized)
if (!data.m_bAuthorized)
{
m_Socket.CloseAcceptedSocket(i);
}

4
r5dev/engine/server/sv_rcon.h
View File

@ -37,13 +37,13 @@ public:
bool Serialize(vector<char>& vecBuf, const char* pResponseMsg, const char* pResponseVal, const sv_rcon::response_t responseType,
const int nMessageId = static_cast<int>(eDLL_T::NETCON), const int nMessageType = static_cast<int>(LogType_t::LOG_NET)) const;
void Authenticate(const cl_rcon::request& request, CConnectedNetConsoleData& pData);
void Authenticate(const cl_rcon::request& request, CConnectedNetConsoleData& data);
bool Comparator(const string& svPassword) const;
virtual bool ProcessMessage(const char* pMsgBuf, const int nMsgLen) override;
void Execute(const cl_rcon::request& request) const;
bool CheckForBan(CConnectedNetConsoleData& pData);
bool CheckForBan(CConnectedNetConsoleData& data);
virtual void Disconnect(const char* szReason = nullptr) override;
void Disconnect(const int nIndex, const char* szReason = nullptr);

53
r5dev/engine/shared/base_rcon.cpp
View File

@ -69,16 +69,16 @@ bool CNetConBase::Send(const SocketHandle_t hSocket, const char* pMsgBuf,
//-----------------------------------------------------------------------------
// Purpose: receive message
// Input : &pData -
// Input : &data -
// nMaxLen -
// Output: true on success, false otherwise
//-----------------------------------------------------------------------------
void CNetConBase::Recv(CConnectedNetConsoleData& pData, const int nMaxLen)
void CNetConBase::Recv(CConnectedNetConsoleData& data, const int nMaxLen)
{
static char szRecvBuf[1024];
{//////////////////////////////////////////////
const int nPendingLen = ::recv(pData.m_hSocket, szRecvBuf, sizeof(char), MSG_PEEK);
const int nPendingLen = ::recv(data.m_hSocket, szRecvBuf, sizeof(char), MSG_PEEK);
if (nPendingLen == SOCKET_ERROR && m_Socket.IsSocketBlocking())
{
return;
@ -96,7 +96,7 @@ void CNetConBase::Recv(CConnectedNetConsoleData& pData, const int nMaxLen)
}//////////////////////////////////////////////
int nReadLen = 0; // Find out how much we have to read.
int iResult = ::ioctlsocket(pData.m_hSocket, FIONREAD, reinterpret_cast<u_long*>(&nReadLen));
int iResult = ::ioctlsocket(data.m_hSocket, FIONREAD, reinterpret_cast<u_long*>(&nReadLen));
if (iResult == SOCKET_ERROR)
{
@ -106,7 +106,7 @@ void CNetConBase::Recv(CConnectedNetConsoleData& pData, const int nMaxLen)
while (nReadLen > 0)
{
const int nRecvLen = ::recv(pData.m_hSocket, szRecvBuf, MIN(sizeof(szRecvBuf), nReadLen), MSG_NOSIGNAL);
const int nRecvLen = ::recv(data.m_hSocket, szRecvBuf, MIN(sizeof(szRecvBuf), nReadLen), MSG_NOSIGNAL);
if (nRecvLen == 0) // Socket was closed.
{
Disconnect("socket closed");
@ -119,7 +119,7 @@ void CNetConBase::Recv(CConnectedNetConsoleData& pData, const int nMaxLen)
}
nReadLen -= nRecvLen; // Process what we've got.
ProcessBuffer(pData, szRecvBuf, nRecvLen, nMaxLen);
ProcessBuffer(data, szRecvBuf, nRecvLen, nMaxLen);
}
return;
@ -127,72 +127,73 @@ void CNetConBase::Recv(CConnectedNetConsoleData& pData, const int nMaxLen)
//-----------------------------------------------------------------------------
// Purpose: parses input response buffer using length-prefix framing
// Input : *pRecvBuf -
// Input : &data -
// *pRecvBuf -
// nRecvLen -
// *pData -
// nMaxLen -
// Output: true on success, false otherwise
//-----------------------------------------------------------------------------
bool CNetConBase::ProcessBuffer(CConnectedNetConsoleData& pData,
bool CNetConBase::ProcessBuffer(CConnectedNetConsoleData& data,
const char* pRecvBuf, int nRecvLen, const int nMaxLen)
{
bool bSuccess = true;
while (nRecvLen > 0)
{
if (pData.m_nPayloadLen)
if (data.m_nPayloadLen)
{
if (pData.m_nPayloadRead < pData.m_nPayloadLen)
if (data.m_nPayloadRead < data.m_nPayloadLen)
{
pData.m_RecvBuffer[pData.m_nPayloadRead++] = *pRecvBuf;
data.m_RecvBuffer[data.m_nPayloadRead++] = *pRecvBuf;
pRecvBuf++;
nRecvLen--;
}
if (pData.m_nPayloadRead == pData.m_nPayloadLen)
if (data.m_nPayloadRead == data.m_nPayloadLen)
{
if (!ProcessMessage(
reinterpret_cast<const char*>(pData.m_RecvBuffer.data()), pData.m_nPayloadLen)
reinterpret_cast<const char*>(data.m_RecvBuffer.data()), data.m_nPayloadLen)
&& bSuccess)
{
bSuccess = false;
}
pData.m_nPayloadLen = 0;
pData.m_nPayloadRead = 0;
data.m_nPayloadLen = 0;
data.m_nPayloadRead = 0;
}
}
else if (pData.m_nPayloadRead+1 <= sizeof(int)) // Read size field.
else if (data.m_nPayloadRead+1 <= sizeof(int)) // Read size field.
{
pData.m_RecvBuffer[pData.m_nPayloadRead++] = *pRecvBuf;
data.m_RecvBuffer[data.m_nPayloadRead++] = *pRecvBuf;
pRecvBuf++;
nRecvLen--;
}
else // Build prefix.
{
pData.m_nPayloadLen = int(ntohl(*reinterpret_cast<u_long*>(&pData.m_RecvBuffer[0])));
pData.m_nPayloadRead = 0;
data.m_nPayloadLen = int(ntohl(*reinterpret_cast<u_long*>(&data.m_RecvBuffer[0])));
data.m_nPayloadRead = 0;
if (!pData.m_bAuthorized && nMaxLen > -1)
if (!data.m_bAuthorized && nMaxLen > -1)
{
if (pData.m_nPayloadLen > nMaxLen)
if (data.m_nPayloadLen > nMaxLen)
{
Disconnect("overflow"); // Sending large messages while not authenticated.
return false;
}
}
if (pData.m_nPayloadLen < 0 ||
pData.m_nPayloadLen > pData.m_RecvBuffer.max_size())
if (data.m_nPayloadLen < 0 ||
data.m_nPayloadLen > data.m_RecvBuffer.max_size())
{
Error(eDLL_T::ENGINE, NO_ERROR, "RCON Cmd: sync error (%d)\n", pData.m_nPayloadLen);
Error(eDLL_T::ENGINE, NO_ERROR, "RCON Cmd: sync error (%d)\n", data.m_nPayloadLen);
Disconnect("desync"); // Out of sync (irrecoverable).
return false;
}
else
{
pData.m_RecvBuffer.resize(pData.m_nPayloadLen);
data.m_RecvBuffer.resize(data.m_nPayloadLen);
}
}
}

4
r5dev/engine/shared/base_rcon.h
View File

@ -18,9 +18,9 @@ public:
virtual void Disconnect(const char* szReason = nullptr) { NOTE_UNUSED(szReason); };
virtual bool Send(const SocketHandle_t hSocket, const char* pMsgBuf, const int nMsgLen) const;
virtual void Recv(CConnectedNetConsoleData& pData, const int nMaxLen = SOCKET_ERROR);
virtual void Recv(CConnectedNetConsoleData& data, const int nMaxLen = SOCKET_ERROR);
virtual bool ProcessBuffer(CConnectedNetConsoleData& pData, const char* pRecvBuf, int nRecvLen, const int nMaxLen = SOCKET_ERROR);
virtual bool ProcessBuffer(CConnectedNetConsoleData& data, const char* pRecvBuf, int nRecvLen, const int nMaxLen = SOCKET_ERROR);
virtual bool ProcessMessage(const char* /*pMsgBuf*/, int /*nMsgLen*/) { return true; };
CSocketCreator* GetSocketCreator(void) { return &m_Socket; }