mirror of
https://github.com/ddnet/ddnet.git
synced 2024-11-11 02:28:18 +00:00
1916 lines
53 KiB
C++
1916 lines
53 KiB
C++
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
|
|
/* If you are missing that file, acquire a complete release at teeworlds.com. */
|
|
|
|
#include <base/math.h>
|
|
#include <base/system.h>
|
|
|
|
#include <engine/config.h>
|
|
#include <engine/console.h>
|
|
#include <engine/engine.h>
|
|
#include <engine/map.h>
|
|
#include <engine/masterserver.h>
|
|
#include <engine/server.h>
|
|
#include <engine/storage.h>
|
|
|
|
#include <engine/shared/compression.h>
|
|
#include <engine/shared/config.h>
|
|
#include <engine/shared/datafile.h>
|
|
#include <engine/shared/demo.h>
|
|
#include <engine/shared/econ.h>
|
|
#include <engine/shared/filecollection.h>
|
|
#include <engine/shared/mapchecker.h>
|
|
#include <engine/shared/netban.h>
|
|
#include <engine/shared/network.h>
|
|
#include <engine/shared/packer.h>
|
|
#include <engine/shared/protocol.h>
|
|
#include <engine/shared/snapshot.h>
|
|
|
|
#include <mastersrv/mastersrv.h>
|
|
|
|
// DDRace
|
|
#include <string.h>
|
|
#include <vector>
|
|
#include <engine/shared/linereader.h>
|
|
|
|
#include "register.h"
|
|
#include "server.h"
|
|
#include "fifoconsole.h"
|
|
|
|
#if defined(CONF_FAMILY_WINDOWS)
|
|
#define _WIN32_WINNT 0x0501
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
static const char *StrUTF8Ltrim(const char *pStr)
|
|
{
|
|
while(*pStr)
|
|
{
|
|
const char *pStrOld = pStr;
|
|
int Code = str_utf8_decode(&pStr);
|
|
|
|
// check if unicode is not empty
|
|
if(Code > 0x20 && Code != 0xA0 && Code != 0x034F && (Code < 0x2000 || Code > 0x200F) && (Code < 0x2028 || Code > 0x202F) &&
|
|
(Code < 0x205F || Code > 0x2064) && (Code < 0x206A || Code > 0x206F) && (Code < 0xFE00 || Code > 0xFE0F) &&
|
|
Code != 0xFEFF && (Code < 0xFFF9 || Code > 0xFFFC))
|
|
{
|
|
return pStrOld;
|
|
}
|
|
}
|
|
return pStr;
|
|
}
|
|
|
|
static void StrUTF8Rtrim(char *pStr)
|
|
{
|
|
const char *p = pStr;
|
|
const char *pEnd = 0;
|
|
while(*p)
|
|
{
|
|
const char *pStrOld = p;
|
|
int Code = str_utf8_decode(&p);
|
|
|
|
// check if unicode is not empty
|
|
if(Code > 0x20 && Code != 0xA0 && Code != 0x034F && (Code < 0x2000 || Code > 0x200F) && (Code < 0x2028 || Code > 0x202F) &&
|
|
(Code < 0x205F || Code > 0x2064) && (Code < 0x206A || Code > 0x206F) && (Code < 0xFE00 || Code > 0xFE0F) &&
|
|
Code != 0xFEFF && (Code < 0xFFF9 || Code > 0xFFFC))
|
|
{
|
|
pEnd = 0;
|
|
}
|
|
else if(pEnd == 0)
|
|
pEnd = pStrOld;
|
|
}
|
|
if(pEnd != 0)
|
|
*(const_cast<char *>(pEnd)) = 0;
|
|
}
|
|
|
|
|
|
CSnapIDPool::CSnapIDPool()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void CSnapIDPool::Reset()
|
|
{
|
|
for(int i = 0; i < MAX_IDS; i++)
|
|
{
|
|
m_aIDs[i].m_Next = i+1;
|
|
m_aIDs[i].m_State = 0;
|
|
}
|
|
|
|
m_aIDs[MAX_IDS-1].m_Next = -1;
|
|
m_FirstFree = 0;
|
|
m_FirstTimed = -1;
|
|
m_LastTimed = -1;
|
|
m_Usage = 0;
|
|
m_InUsage = 0;
|
|
}
|
|
|
|
|
|
void CSnapIDPool::RemoveFirstTimeout()
|
|
{
|
|
int NextTimed = m_aIDs[m_FirstTimed].m_Next;
|
|
|
|
// add it to the free list
|
|
m_aIDs[m_FirstTimed].m_Next = m_FirstFree;
|
|
m_aIDs[m_FirstTimed].m_State = 0;
|
|
m_FirstFree = m_FirstTimed;
|
|
|
|
// remove it from the timed list
|
|
m_FirstTimed = NextTimed;
|
|
if(m_FirstTimed == -1)
|
|
m_LastTimed = -1;
|
|
|
|
m_Usage--;
|
|
}
|
|
|
|
int CSnapIDPool::NewID()
|
|
{
|
|
int64 Now = time_get();
|
|
|
|
// process timed ids
|
|
while(m_FirstTimed != -1 && m_aIDs[m_FirstTimed].m_Timeout < Now)
|
|
RemoveFirstTimeout();
|
|
|
|
int ID = m_FirstFree;
|
|
dbg_assert(ID != -1, "id error");
|
|
if(ID == -1)
|
|
return ID;
|
|
m_FirstFree = m_aIDs[m_FirstFree].m_Next;
|
|
m_aIDs[ID].m_State = 1;
|
|
m_Usage++;
|
|
m_InUsage++;
|
|
return ID;
|
|
}
|
|
|
|
void CSnapIDPool::TimeoutIDs()
|
|
{
|
|
// process timed ids
|
|
while(m_FirstTimed != -1)
|
|
RemoveFirstTimeout();
|
|
}
|
|
|
|
void CSnapIDPool::FreeID(int ID)
|
|
{
|
|
if(ID < 0)
|
|
return;
|
|
dbg_assert(m_aIDs[ID].m_State == 1, "id is not alloced");
|
|
|
|
m_InUsage--;
|
|
m_aIDs[ID].m_State = 2;
|
|
m_aIDs[ID].m_Timeout = time_get()+time_freq()*5;
|
|
m_aIDs[ID].m_Next = -1;
|
|
|
|
if(m_LastTimed != -1)
|
|
{
|
|
m_aIDs[m_LastTimed].m_Next = ID;
|
|
m_LastTimed = ID;
|
|
}
|
|
else
|
|
{
|
|
m_FirstTimed = ID;
|
|
m_LastTimed = ID;
|
|
}
|
|
}
|
|
|
|
|
|
void CServerBan::Init(IConsole *pConsole, IStorage *pStorage, CServer* pServer)
|
|
{
|
|
CNetBan::Init(pConsole, pStorage);
|
|
|
|
m_pServer = pServer;
|
|
|
|
// overwrites base command, todo: improve this
|
|
Console()->Register("ban", "s?ir", CFGFLAG_SERVER|CFGFLAG_STORE, ConBanExt, this, "Ban player with ip/client id for x minutes for any reason");
|
|
}
|
|
|
|
template<class T>
|
|
int CServerBan::BanExt(T *pBanPool, const typename T::CDataType *pData, int Seconds, const char *pReason)
|
|
{
|
|
// validate address
|
|
if(Server()->m_RconClientID >= 0 && Server()->m_RconClientID < MAX_CLIENTS &&
|
|
Server()->m_aClients[Server()->m_RconClientID].m_State != CServer::CClient::STATE_EMPTY)
|
|
{
|
|
if(NetMatch(pData, Server()->m_NetServer.ClientAddr(Server()->m_RconClientID)))
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "net_ban", "ban error (you can't ban yourself)");
|
|
return -1;
|
|
}
|
|
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(i == Server()->m_RconClientID || Server()->m_aClients[i].m_State == CServer::CClient::STATE_EMPTY)
|
|
continue;
|
|
|
|
if(Server()->m_aClients[i].m_Authed >= Server()->m_RconAuthLevel && NetMatch(pData, Server()->m_NetServer.ClientAddr(i)))
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "net_ban", "ban error (command denied)");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
else if(Server()->m_RconClientID == IServer::RCON_CID_VOTE)
|
|
{
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(Server()->m_aClients[i].m_State == CServer::CClient::STATE_EMPTY)
|
|
continue;
|
|
|
|
if(Server()->m_aClients[i].m_Authed != CServer::AUTHED_NO && NetMatch(pData, Server()->m_NetServer.ClientAddr(i)))
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "net_ban", "ban error (command denied)");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int Result = Ban(pBanPool, pData, Seconds, pReason);
|
|
if(Result != 0)
|
|
return Result;
|
|
|
|
// drop banned clients
|
|
typename T::CDataType Data = *pData;
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(Server()->m_aClients[i].m_State == CServer::CClient::STATE_EMPTY)
|
|
continue;
|
|
|
|
if(NetMatch(&Data, Server()->m_NetServer.ClientAddr(i)))
|
|
{
|
|
CNetHash NetHash(&Data);
|
|
char aBuf[256];
|
|
MakeBanInfo(pBanPool->Find(&Data, &NetHash), aBuf, sizeof(aBuf), MSGTYPE_PLAYER);
|
|
Server()->m_NetServer.Drop(i, aBuf);
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
int CServerBan::BanAddr(const NETADDR *pAddr, int Seconds, const char *pReason)
|
|
{
|
|
return BanExt(&m_BanAddrPool, pAddr, Seconds, pReason);
|
|
}
|
|
|
|
int CServerBan::BanRange(const CNetRange *pRange, int Seconds, const char *pReason)
|
|
{
|
|
if(pRange->IsValid())
|
|
return BanExt(&m_BanRangePool, pRange, Seconds, pReason);
|
|
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "net_ban", "ban failed (invalid range)");
|
|
return -1;
|
|
}
|
|
|
|
void CServerBan::ConBanExt(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
CServerBan *pThis = static_cast<CServerBan *>(pUser);
|
|
|
|
const char *pStr = pResult->GetString(0);
|
|
int Minutes = pResult->NumArguments()>1 ? clamp(pResult->GetInteger(1), 0, 44640) : 30;
|
|
const char *pReason = pResult->NumArguments()>2 ? pResult->GetString(2) : "No reason given";
|
|
|
|
if(StrAllnum(pStr))
|
|
{
|
|
int ClientID = str_toint(pStr);
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || pThis->Server()->m_aClients[ClientID].m_State == CServer::CClient::STATE_EMPTY)
|
|
pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "net_ban", "ban error (invalid client id)");
|
|
else
|
|
pThis->BanAddr(pThis->Server()->m_NetServer.ClientAddr(ClientID), Minutes*60, pReason);
|
|
}
|
|
else
|
|
ConBan(pResult, pUser);
|
|
}
|
|
|
|
|
|
void CServer::CClient::Reset()
|
|
{
|
|
// reset input
|
|
for(int i = 0; i < 200; i++)
|
|
m_aInputs[i].m_GameTick = -1;
|
|
m_CurrentInput = 0;
|
|
mem_zero(&m_LatestInput, sizeof(m_LatestInput));
|
|
|
|
m_Snapshots.PurgeAll();
|
|
m_LastAckedSnapshot = -1;
|
|
m_LastInputTick = -1;
|
|
m_SnapRate = CClient::SNAPRATE_INIT;
|
|
m_Score = 0;
|
|
}
|
|
|
|
CServer::CServer() : m_DemoRecorder(&m_SnapshotDelta)
|
|
{
|
|
m_TickSpeed = SERVER_TICK_SPEED;
|
|
|
|
m_pGameServer = 0;
|
|
|
|
m_CurrentGameTick = 0;
|
|
m_RunServer = 1;
|
|
|
|
m_pCurrentMapData = 0;
|
|
m_CurrentMapSize = 0;
|
|
|
|
m_MapReload = 0;
|
|
|
|
m_RconClientID = IServer::RCON_CID_SERV;
|
|
m_RconAuthLevel = AUTHED_ADMIN;
|
|
|
|
m_RconRestrict = -1;
|
|
|
|
Init();
|
|
}
|
|
|
|
|
|
int CServer::TrySetClientName(int ClientID, const char *pName)
|
|
{
|
|
char aTrimmedName[64];
|
|
|
|
// trim the name
|
|
str_copy(aTrimmedName, StrUTF8Ltrim(pName), sizeof(aTrimmedName));
|
|
StrUTF8Rtrim(aTrimmedName);
|
|
|
|
// check if new and old name are the same
|
|
if(m_aClients[ClientID].m_aName[0] && str_comp(m_aClients[ClientID].m_aName, aTrimmedName) == 0)
|
|
return 0;
|
|
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "'%s' -> '%s'", pName, aTrimmedName);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBuf);
|
|
pName = aTrimmedName;
|
|
|
|
|
|
// check for empty names
|
|
if(!pName[0])
|
|
return -1;
|
|
|
|
// make sure that two clients doesn't have the same name
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
if(i != ClientID && m_aClients[i].m_State >= CClient::STATE_READY)
|
|
{
|
|
if(str_comp(pName, m_aClients[i].m_aName) == 0)
|
|
return -1;
|
|
}
|
|
|
|
// set the client name
|
|
str_copy(m_aClients[ClientID].m_aName, pName, MAX_NAME_LENGTH);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void CServer::SetClientName(int ClientID, const char *pName)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State < CClient::STATE_READY)
|
|
return;
|
|
|
|
if(!pName)
|
|
return;
|
|
|
|
char aNameTry[MAX_NAME_LENGTH];
|
|
str_copy(aNameTry, pName, MAX_NAME_LENGTH);
|
|
if(TrySetClientName(ClientID, aNameTry))
|
|
{
|
|
// auto rename
|
|
for(int i = 1;; i++)
|
|
{
|
|
str_format(aNameTry, MAX_NAME_LENGTH, "(%d)%s", i, pName);
|
|
if(TrySetClientName(ClientID, aNameTry) == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CServer::SetClientClan(int ClientID, const char *pClan)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State < CClient::STATE_READY || !pClan)
|
|
return;
|
|
|
|
str_copy(m_aClients[ClientID].m_aClan, pClan, MAX_CLAN_LENGTH);
|
|
}
|
|
|
|
void CServer::SetClientCountry(int ClientID, int Country)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State < CClient::STATE_READY)
|
|
return;
|
|
|
|
m_aClients[ClientID].m_Country = Country;
|
|
}
|
|
|
|
void CServer::SetClientScore(int ClientID, int Score)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State < CClient::STATE_READY)
|
|
return;
|
|
m_aClients[ClientID].m_Score = Score;
|
|
}
|
|
|
|
void CServer::Kick(int ClientID, const char *pReason)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State == CClient::STATE_EMPTY)
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "invalid client id to kick");
|
|
return;
|
|
}
|
|
else if(m_RconClientID == ClientID)
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "you can't kick yourself");
|
|
return;
|
|
}
|
|
else if(m_aClients[ClientID].m_Authed > m_RconAuthLevel)
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "kick command denied");
|
|
return;
|
|
}
|
|
|
|
m_NetServer.Drop(ClientID, pReason);
|
|
}
|
|
|
|
/*int CServer::Tick()
|
|
{
|
|
return m_CurrentGameTick;
|
|
}*/
|
|
|
|
int64 CServer::TickStartTime(int Tick)
|
|
{
|
|
return m_GameStartTime + (time_freq()*Tick)/SERVER_TICK_SPEED;
|
|
}
|
|
|
|
/*int CServer::TickSpeed()
|
|
{
|
|
return SERVER_TICK_SPEED;
|
|
}*/
|
|
|
|
int CServer::Init()
|
|
{
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
m_aClients[i].m_State = CClient::STATE_EMPTY;
|
|
m_aClients[i].m_aName[0] = 0;
|
|
m_aClients[i].m_aClan[0] = 0;
|
|
m_aClients[i].m_Country = -1;
|
|
m_aClients[i].m_Snapshots.Init();
|
|
m_aClients[i].m_Traffic = 0;
|
|
m_aClients[i].m_TrafficSince = 0;
|
|
}
|
|
|
|
m_CurrentGameTick = 0;
|
|
|
|
m_AnnouncementLastLine = 0;
|
|
memset(m_aPrevStates, CClient::STATE_EMPTY, MAX_CLIENTS * sizeof(int));
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CServer::SetRconCID(int ClientID)
|
|
{
|
|
m_RconClientID = ClientID;
|
|
}
|
|
|
|
bool CServer::IsAuthed(int ClientID)
|
|
{
|
|
return m_aClients[ClientID].m_Authed;
|
|
}
|
|
|
|
int CServer::GetClientInfo(int ClientID, CClientInfo *pInfo)
|
|
{
|
|
dbg_assert(ClientID >= 0 && ClientID < MAX_CLIENTS, "client_id is not valid");
|
|
dbg_assert(pInfo != 0, "info can not be null");
|
|
|
|
if(m_aClients[ClientID].m_State == CClient::STATE_INGAME)
|
|
{
|
|
pInfo->m_pName = m_aClients[ClientID].m_aName;
|
|
pInfo->m_Latency = m_aClients[ClientID].m_Latency;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CServer::GetClientAddr(int ClientID, char *pAddrStr, int Size)
|
|
{
|
|
if(ClientID >= 0 && ClientID < MAX_CLIENTS && m_aClients[ClientID].m_State == CClient::STATE_INGAME)
|
|
net_addr_str(m_NetServer.ClientAddr(ClientID), pAddrStr, Size, false);
|
|
}
|
|
|
|
|
|
const char *CServer::ClientName(int ClientID)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State == CServer::CClient::STATE_EMPTY)
|
|
return "(invalid)";
|
|
if(m_aClients[ClientID].m_State == CServer::CClient::STATE_INGAME)
|
|
return m_aClients[ClientID].m_aName;
|
|
else
|
|
return "(connecting)";
|
|
|
|
}
|
|
|
|
const char *CServer::ClientClan(int ClientID)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State == CServer::CClient::STATE_EMPTY)
|
|
return "";
|
|
if(m_aClients[ClientID].m_State == CServer::CClient::STATE_INGAME)
|
|
return m_aClients[ClientID].m_aClan;
|
|
else
|
|
return "";
|
|
}
|
|
|
|
int CServer::ClientCountry(int ClientID)
|
|
{
|
|
if(ClientID < 0 || ClientID >= MAX_CLIENTS || m_aClients[ClientID].m_State == CServer::CClient::STATE_EMPTY)
|
|
return -1;
|
|
if(m_aClients[ClientID].m_State == CServer::CClient::STATE_INGAME)
|
|
return m_aClients[ClientID].m_Country;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
bool CServer::ClientIngame(int ClientID)
|
|
{
|
|
return ClientID >= 0 && ClientID < MAX_CLIENTS && m_aClients[ClientID].m_State == CServer::CClient::STATE_INGAME;
|
|
}
|
|
|
|
int CServer::MaxClients() const
|
|
{
|
|
return m_NetServer.MaxClients();
|
|
}
|
|
|
|
int CServer::SendMsg(CMsgPacker *pMsg, int Flags, int ClientID)
|
|
{
|
|
return SendMsgEx(pMsg, Flags, ClientID, false);
|
|
}
|
|
|
|
int CServer::SendMsgEx(CMsgPacker *pMsg, int Flags, int ClientID, bool System)
|
|
{
|
|
CNetChunk Packet;
|
|
if(!pMsg)
|
|
return -1;
|
|
|
|
mem_zero(&Packet, sizeof(CNetChunk));
|
|
|
|
Packet.m_ClientID = ClientID;
|
|
Packet.m_pData = pMsg->Data();
|
|
Packet.m_DataSize = pMsg->Size();
|
|
|
|
// HACK: modify the message id in the packet and store the system flag
|
|
*((unsigned char*)Packet.m_pData) <<= 1;
|
|
if(System)
|
|
*((unsigned char*)Packet.m_pData) |= 1;
|
|
|
|
if(Flags&MSGFLAG_VITAL)
|
|
Packet.m_Flags |= NETSENDFLAG_VITAL;
|
|
if(Flags&MSGFLAG_FLUSH)
|
|
Packet.m_Flags |= NETSENDFLAG_FLUSH;
|
|
|
|
// write message to demo recorder
|
|
if(!(Flags&MSGFLAG_NORECORD))
|
|
m_DemoRecorder.RecordMessage(pMsg->Data(), pMsg->Size());
|
|
|
|
if(!(Flags&MSGFLAG_NOSEND))
|
|
{
|
|
if(ClientID == -1)
|
|
{
|
|
// broadcast
|
|
int i;
|
|
for(i = 0; i < MAX_CLIENTS; i++)
|
|
if(m_aClients[i].m_State == CClient::STATE_INGAME)
|
|
{
|
|
Packet.m_ClientID = i;
|
|
m_NetServer.Send(&Packet);
|
|
}
|
|
}
|
|
else
|
|
m_NetServer.Send(&Packet);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CServer::DoSnapshot()
|
|
{
|
|
GameServer()->OnPreSnap();
|
|
|
|
// create snapshot for demo recording
|
|
if(m_DemoRecorder.IsRecording())
|
|
{
|
|
char aData[CSnapshot::MAX_SIZE];
|
|
int SnapshotSize;
|
|
|
|
// build snap and possibly add some messages
|
|
m_SnapshotBuilder.Init();
|
|
GameServer()->OnSnap(-1);
|
|
SnapshotSize = m_SnapshotBuilder.Finish(aData);
|
|
|
|
// write snapshot
|
|
m_DemoRecorder.RecordSnapshot(Tick(), aData, SnapshotSize);
|
|
}
|
|
|
|
// create snapshots for all clients
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
// client must be ingame to recive snapshots
|
|
if(m_aClients[i].m_State != CClient::STATE_INGAME)
|
|
continue;
|
|
|
|
// this client is trying to recover, don't spam snapshots
|
|
if(m_aClients[i].m_SnapRate == CClient::SNAPRATE_RECOVER && (Tick()%50) != 0)
|
|
continue;
|
|
|
|
// this client is trying to recover, don't spam snapshots
|
|
if(m_aClients[i].m_SnapRate == CClient::SNAPRATE_INIT && (Tick()%10) != 0)
|
|
continue;
|
|
|
|
{
|
|
char aData[CSnapshot::MAX_SIZE];
|
|
CSnapshot *pData = (CSnapshot*)aData; // Fix compiler warning for strict-aliasing
|
|
char aDeltaData[CSnapshot::MAX_SIZE];
|
|
char aCompData[CSnapshot::MAX_SIZE];
|
|
int SnapshotSize;
|
|
int Crc;
|
|
static CSnapshot EmptySnap;
|
|
CSnapshot *pDeltashot = &EmptySnap;
|
|
int DeltashotSize;
|
|
int DeltaTick = -1;
|
|
int DeltaSize;
|
|
|
|
m_SnapshotBuilder.Init();
|
|
|
|
GameServer()->OnSnap(i);
|
|
|
|
// finish snapshot
|
|
SnapshotSize = m_SnapshotBuilder.Finish(pData);
|
|
Crc = pData->Crc();
|
|
|
|
// remove old snapshos
|
|
// keep 3 seconds worth of snapshots
|
|
m_aClients[i].m_Snapshots.PurgeUntil(m_CurrentGameTick-SERVER_TICK_SPEED*3);
|
|
|
|
// save it the snapshot
|
|
m_aClients[i].m_Snapshots.Add(m_CurrentGameTick, time_get(), SnapshotSize, pData, 0);
|
|
|
|
// find snapshot that we can preform delta against
|
|
EmptySnap.Clear();
|
|
|
|
{
|
|
DeltashotSize = m_aClients[i].m_Snapshots.Get(m_aClients[i].m_LastAckedSnapshot, 0, &pDeltashot, 0);
|
|
if(DeltashotSize >= 0)
|
|
DeltaTick = m_aClients[i].m_LastAckedSnapshot;
|
|
else
|
|
{
|
|
// no acked package found, force client to recover rate
|
|
if(m_aClients[i].m_SnapRate == CClient::SNAPRATE_FULL)
|
|
m_aClients[i].m_SnapRate = CClient::SNAPRATE_RECOVER;
|
|
}
|
|
}
|
|
|
|
// create delta
|
|
DeltaSize = m_SnapshotDelta.CreateDelta(pDeltashot, pData, aDeltaData);
|
|
|
|
if(DeltaSize)
|
|
{
|
|
// compress it
|
|
int SnapshotSize;
|
|
const int MaxSize = MAX_SNAPSHOT_PACKSIZE;
|
|
int NumPackets;
|
|
|
|
SnapshotSize = CVariableInt::Compress(aDeltaData, DeltaSize, aCompData);
|
|
NumPackets = (SnapshotSize+MaxSize-1)/MaxSize;
|
|
|
|
for(int n = 0, Left = SnapshotSize; Left; n++)
|
|
{
|
|
int Chunk = Left < MaxSize ? Left : MaxSize;
|
|
Left -= Chunk;
|
|
|
|
if(NumPackets == 1)
|
|
{
|
|
CMsgPacker Msg(NETMSG_SNAPSINGLE);
|
|
Msg.AddInt(m_CurrentGameTick);
|
|
Msg.AddInt(m_CurrentGameTick-DeltaTick);
|
|
Msg.AddInt(Crc);
|
|
Msg.AddInt(Chunk);
|
|
Msg.AddRaw(&aCompData[n*MaxSize], Chunk);
|
|
SendMsgEx(&Msg, MSGFLAG_FLUSH, i, true);
|
|
}
|
|
else
|
|
{
|
|
CMsgPacker Msg(NETMSG_SNAP);
|
|
Msg.AddInt(m_CurrentGameTick);
|
|
Msg.AddInt(m_CurrentGameTick-DeltaTick);
|
|
Msg.AddInt(NumPackets);
|
|
Msg.AddInt(n);
|
|
Msg.AddInt(Crc);
|
|
Msg.AddInt(Chunk);
|
|
Msg.AddRaw(&aCompData[n*MaxSize], Chunk);
|
|
SendMsgEx(&Msg, MSGFLAG_FLUSH, i, true);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMsgPacker Msg(NETMSG_SNAPEMPTY);
|
|
Msg.AddInt(m_CurrentGameTick);
|
|
Msg.AddInt(m_CurrentGameTick-DeltaTick);
|
|
SendMsgEx(&Msg, MSGFLAG_FLUSH, i, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
GameServer()->OnPostSnap();
|
|
}
|
|
|
|
|
|
int CServer::NewClientCallback(int ClientID, void *pUser)
|
|
{
|
|
CServer *pThis = (CServer *)pUser;
|
|
pThis->m_aClients[ClientID].m_State = CClient::STATE_AUTH;
|
|
pThis->m_aClients[ClientID].m_aName[0] = 0;
|
|
pThis->m_aClients[ClientID].m_aClan[0] = 0;
|
|
pThis->m_aClients[ClientID].m_Country = -1;
|
|
pThis->m_aClients[ClientID].m_Authed = AUTHED_NO;
|
|
pThis->m_aClients[ClientID].m_AuthTries = 0;
|
|
pThis->m_aClients[ClientID].m_pRconCmdToSend = 0;
|
|
pThis->m_aClients[ClientID].Reset();
|
|
return 0;
|
|
}
|
|
|
|
int CServer::DelClientCallback(int ClientID, const char *pReason, void *pUser)
|
|
{
|
|
CServer *pThis = (CServer *)pUser;
|
|
|
|
char aAddrStr[NETADDR_MAXSTRSIZE];
|
|
net_addr_str(pThis->m_NetServer.ClientAddr(ClientID), aAddrStr, sizeof(aAddrStr), true);
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "client dropped. cid=%d addr=%s reason='%s'", ClientID, aAddrStr, pReason);
|
|
pThis->Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBuf);
|
|
|
|
// notify the mod about the drop
|
|
if(pThis->m_aClients[ClientID].m_State >= CClient::STATE_READY)
|
|
pThis->GameServer()->OnClientDrop(ClientID, pReason);
|
|
|
|
pThis->m_aClients[ClientID].m_State = CClient::STATE_EMPTY;
|
|
pThis->m_aClients[ClientID].m_aName[0] = 0;
|
|
pThis->m_aClients[ClientID].m_aClan[0] = 0;
|
|
pThis->m_aClients[ClientID].m_Country = -1;
|
|
pThis->m_aClients[ClientID].m_Authed = AUTHED_NO;
|
|
pThis->m_aClients[ClientID].m_AuthTries = 0;
|
|
pThis->m_aClients[ClientID].m_pRconCmdToSend = 0;
|
|
pThis->m_aPrevStates[ClientID] = CClient::STATE_EMPTY;
|
|
pThis->m_aClients[ClientID].m_Snapshots.PurgeAll();
|
|
return 0;
|
|
}
|
|
|
|
static int lastsent[MAX_CLIENTS];
|
|
static int lastask[MAX_CLIENTS];
|
|
static int lastasktick[MAX_CLIENTS];
|
|
|
|
void CServer::SendMap(int ClientID)
|
|
{
|
|
lastsent[ClientID] = 0;
|
|
lastask[ClientID] = 0;
|
|
lastasktick[ClientID] = Tick();
|
|
CMsgPacker Msg(NETMSG_MAP_CHANGE);
|
|
Msg.AddString(GetMapName(), 0);
|
|
Msg.AddInt(m_CurrentMapCrc);
|
|
Msg.AddInt(m_CurrentMapSize);
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL|MSGFLAG_FLUSH, ClientID, true);
|
|
}
|
|
|
|
void CServer::SendConnectionReady(int ClientID)
|
|
{
|
|
CMsgPacker Msg(NETMSG_CON_READY);
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL|MSGFLAG_FLUSH, ClientID, true);
|
|
}
|
|
|
|
void CServer::SendRconLine(int ClientID, const char *pLine)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_LINE);
|
|
Msg.AddString(pLine, 512);
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true);
|
|
}
|
|
|
|
void CServer::SendRconLineAuthed(const char *pLine, void *pUser)
|
|
{
|
|
CServer *pThis = (CServer *)pUser;
|
|
static volatile int ReentryGuard = 0;
|
|
int i;
|
|
|
|
if(ReentryGuard) return;
|
|
ReentryGuard++;
|
|
|
|
for(i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
if(pThis->m_aClients[i].m_State != CClient::STATE_EMPTY && pThis->m_aClients[i].m_Authed >= pThis->m_RconAuthLevel && (pThis->m_RconRestrict == -1 || pThis->m_RconRestrict == i))
|
|
pThis->SendRconLine(i, pLine);
|
|
}
|
|
|
|
ReentryGuard--;
|
|
}
|
|
|
|
void CServer::SendRconCmdAdd(const IConsole::CCommandInfo *pCommandInfo, int ClientID)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_CMD_ADD);
|
|
Msg.AddString(pCommandInfo->m_pName, IConsole::TEMPCMD_NAME_LENGTH);
|
|
Msg.AddString(pCommandInfo->m_pHelp, IConsole::TEMPCMD_HELP_LENGTH);
|
|
Msg.AddString(pCommandInfo->m_pParams, IConsole::TEMPCMD_PARAMS_LENGTH);
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true);
|
|
}
|
|
|
|
void CServer::SendRconCmdRem(const IConsole::CCommandInfo *pCommandInfo, int ClientID)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_CMD_REM);
|
|
Msg.AddString(pCommandInfo->m_pName, 256);
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true);
|
|
}
|
|
|
|
void CServer::UpdateClientRconCommands()
|
|
{
|
|
int ClientID = Tick() % MAX_CLIENTS;
|
|
|
|
if(m_aClients[ClientID].m_State != CClient::STATE_EMPTY && m_aClients[ClientID].m_Authed)
|
|
{
|
|
int ConsoleAccessLevel = m_aClients[ClientID].m_Authed == AUTHED_ADMIN ? IConsole::ACCESS_LEVEL_ADMIN : IConsole::ACCESS_LEVEL_MOD;
|
|
for(int i = 0; i < MAX_RCONCMD_SEND && m_aClients[ClientID].m_pRconCmdToSend; ++i)
|
|
{
|
|
SendRconCmdAdd(m_aClients[ClientID].m_pRconCmdToSend, ClientID);
|
|
m_aClients[ClientID].m_pRconCmdToSend = m_aClients[ClientID].m_pRconCmdToSend->NextCommandInfo(ConsoleAccessLevel, CFGFLAG_SERVER);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CServer::ProcessClientPacket(CNetChunk *pPacket)
|
|
{
|
|
int ClientID = pPacket->m_ClientID;
|
|
CUnpacker Unpacker;
|
|
Unpacker.Reset(pPacket->m_pData, pPacket->m_DataSize);
|
|
|
|
// unpack msgid and system flag
|
|
int Msg = Unpacker.GetInt();
|
|
int Sys = Msg&1;
|
|
Msg >>= 1;
|
|
|
|
if(Unpacker.Error())
|
|
return;
|
|
|
|
int64 Now = time_get();
|
|
|
|
if(Msg != NETMSG_REQUEST_MAP_DATA)
|
|
{
|
|
if (Now - m_aClients[ClientID].m_TrafficSince > time_freq() * 5)
|
|
{
|
|
m_aClients[ClientID].m_Traffic = 0;
|
|
m_aClients[ClientID].m_TrafficSince = Now;
|
|
}
|
|
else
|
|
{
|
|
if ((Now - m_aClients[ClientID].m_TrafficSince) / time_freq() > 0 && m_aClients[ClientID].m_Traffic / ((Now - m_aClients[ClientID].m_TrafficSince) / time_freq()) > 100000)
|
|
{
|
|
m_NetServer.NetBan()->BanAddr(&pPacket->m_Address, 60, "Stressing network");
|
|
return;
|
|
}
|
|
m_aClients[ClientID].m_Traffic += pPacket->m_DataSize;
|
|
}
|
|
}
|
|
|
|
if(Sys)
|
|
{
|
|
// system message
|
|
if(Msg == NETMSG_INFO)
|
|
{
|
|
if(m_aClients[ClientID].m_State == CClient::STATE_AUTH)
|
|
{
|
|
const char *pVersion = Unpacker.GetString(CUnpacker::SANITIZE_CC);
|
|
if(str_comp(pVersion, GameServer()->NetVersion()) != 0)
|
|
{
|
|
// wrong version
|
|
char aReason[256];
|
|
str_format(aReason, sizeof(aReason), "Wrong version. Server is running '%s' and client '%s'", GameServer()->NetVersion(), pVersion);
|
|
m_NetServer.Drop(ClientID, aReason);
|
|
return;
|
|
}
|
|
|
|
const char *pPassword = Unpacker.GetString(CUnpacker::SANITIZE_CC);
|
|
if(g_Config.m_Password[0] != 0 && str_comp(g_Config.m_Password, pPassword) != 0)
|
|
{
|
|
// wrong password
|
|
m_NetServer.Drop(ClientID, "Wrong password");
|
|
return;
|
|
}
|
|
|
|
// reserved slot
|
|
if(ClientID >= (g_Config.m_SvMaxClients - g_Config.m_SvReservedSlots) && g_Config.m_SvReservedSlotsPass[0] != 0 && strcmp(g_Config.m_SvReservedSlotsPass, pPassword) != 0)
|
|
{
|
|
m_NetServer.Drop(ClientID, "This server is full");
|
|
return;
|
|
}
|
|
|
|
m_aClients[ClientID].m_State = CClient::STATE_CONNECTING;
|
|
SendMap(ClientID);
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_REQUEST_MAP_DATA)
|
|
{
|
|
if(m_aClients[ClientID].m_State < CClient::STATE_CONNECTING)
|
|
return; // no map w/o password, sorry guys
|
|
|
|
int Chunk = Unpacker.GetInt();
|
|
int ChunkSize = 1024-128;
|
|
int Offset = Chunk * ChunkSize;
|
|
int Last = 0;
|
|
|
|
lastask[ClientID] = Chunk;
|
|
lastasktick[ClientID] = Tick();
|
|
if (Chunk == 0)
|
|
{
|
|
lastsent[ClientID] = 0;
|
|
}
|
|
|
|
// drop faulty map data requests
|
|
if(Chunk < 0 || Offset > m_CurrentMapSize)
|
|
return;
|
|
|
|
if(Offset+ChunkSize >= m_CurrentMapSize)
|
|
{
|
|
ChunkSize = m_CurrentMapSize-Offset;
|
|
if(ChunkSize < 0)
|
|
ChunkSize = 0;
|
|
Last = 1;
|
|
}
|
|
|
|
if (lastsent[ClientID] < Chunk+g_Config.m_SvMapWindow && g_Config.m_SvFastDownload)
|
|
return;
|
|
|
|
CMsgPacker Msg(NETMSG_MAP_DATA);
|
|
Msg.AddInt(Last);
|
|
Msg.AddInt(m_CurrentMapCrc);
|
|
Msg.AddInt(Chunk);
|
|
Msg.AddInt(ChunkSize);
|
|
Msg.AddRaw(&m_pCurrentMapData[Offset], ChunkSize);
|
|
SendMsgEx(&Msg, MSGFLAG_FLUSH, ClientID, true);
|
|
|
|
if(g_Config.m_Debug)
|
|
{
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "sending chunk %d with size %d", Chunk, ChunkSize);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBuf);
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_READY)
|
|
{
|
|
if(m_aClients[ClientID].m_State == CClient::STATE_CONNECTING)
|
|
{
|
|
char aAddrStr[NETADDR_MAXSTRSIZE];
|
|
net_addr_str(m_NetServer.ClientAddr(ClientID), aAddrStr, sizeof(aAddrStr), true);
|
|
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "player is ready. ClientID=%x addr=%s", ClientID, aAddrStr);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBuf);
|
|
m_aClients[ClientID].m_State = CClient::STATE_READY;
|
|
GameServer()->OnClientConnected(ClientID);
|
|
SendConnectionReady(ClientID);
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_ENTERGAME)
|
|
{
|
|
if(m_aClients[ClientID].m_State == CClient::STATE_READY && GameServer()->IsClientReady(ClientID))
|
|
{
|
|
char aAddrStr[NETADDR_MAXSTRSIZE];
|
|
net_addr_str(m_NetServer.ClientAddr(ClientID), aAddrStr, sizeof(aAddrStr), true);
|
|
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "player has entered the game. ClientID=%x addr=%s", ClientID, aAddrStr);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
m_aClients[ClientID].m_State = CClient::STATE_INGAME;
|
|
GameServer()->OnClientEnter(ClientID);
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_INPUT)
|
|
{
|
|
CClient::CInput *pInput;
|
|
int64 TagTime;
|
|
|
|
m_aClients[ClientID].m_LastAckedSnapshot = Unpacker.GetInt();
|
|
int IntendedTick = Unpacker.GetInt();
|
|
int Size = Unpacker.GetInt();
|
|
|
|
// check for errors
|
|
if(Unpacker.Error() || Size/4 > MAX_INPUT_SIZE)
|
|
return;
|
|
|
|
if(m_aClients[ClientID].m_LastAckedSnapshot > 0)
|
|
m_aClients[ClientID].m_SnapRate = CClient::SNAPRATE_FULL;
|
|
|
|
if(m_aClients[ClientID].m_Snapshots.Get(m_aClients[ClientID].m_LastAckedSnapshot, &TagTime, 0, 0) >= 0)
|
|
m_aClients[ClientID].m_Latency = (int)(((time_get()-TagTime)*1000)/time_freq());
|
|
|
|
// add message to report the input timing
|
|
// skip packets that are old
|
|
if(IntendedTick > m_aClients[ClientID].m_LastInputTick)
|
|
{
|
|
int TimeLeft = ((TickStartTime(IntendedTick)-time_get())*1000) / time_freq();
|
|
|
|
CMsgPacker Msg(NETMSG_INPUTTIMING);
|
|
Msg.AddInt(IntendedTick);
|
|
Msg.AddInt(TimeLeft);
|
|
SendMsgEx(&Msg, 0, ClientID, true);
|
|
}
|
|
|
|
m_aClients[ClientID].m_LastInputTick = IntendedTick;
|
|
|
|
pInput = &m_aClients[ClientID].m_aInputs[m_aClients[ClientID].m_CurrentInput];
|
|
|
|
if(IntendedTick <= Tick())
|
|
IntendedTick = Tick()+1;
|
|
|
|
pInput->m_GameTick = IntendedTick;
|
|
|
|
for(int i = 0; i < Size/4; i++)
|
|
pInput->m_aData[i] = Unpacker.GetInt();
|
|
|
|
mem_copy(m_aClients[ClientID].m_LatestInput.m_aData, pInput->m_aData, MAX_INPUT_SIZE*sizeof(int));
|
|
|
|
m_aClients[ClientID].m_CurrentInput++;
|
|
m_aClients[ClientID].m_CurrentInput %= 200;
|
|
|
|
// call the mod with the fresh input data
|
|
if(m_aClients[ClientID].m_State == CClient::STATE_INGAME)
|
|
GameServer()->OnClientDirectInput(ClientID, m_aClients[ClientID].m_LatestInput.m_aData);
|
|
}
|
|
else if(Msg == NETMSG_RCON_CMD)
|
|
{
|
|
const char *pCmd = Unpacker.GetString();
|
|
|
|
if(Unpacker.Error() == 0 && m_aClients[ClientID].m_Authed)
|
|
{
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "ClientID=%d rcon='%s'", ClientID, pCmd);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBuf);
|
|
m_RconClientID = ClientID;
|
|
m_RconAuthLevel = m_aClients[ClientID].m_Authed;
|
|
Console()->SetAccessLevel(m_aClients[ClientID].m_Authed == AUTHED_ADMIN ? IConsole::ACCESS_LEVEL_ADMIN : m_aClients[ClientID].m_Authed == AUTHED_MOD ? IConsole::ACCESS_LEVEL_MOD : IConsole::ACCESS_LEVEL_USER);
|
|
Console()->ExecuteLineFlag(pCmd, CFGFLAG_SERVER, ClientID);
|
|
Console()->SetAccessLevel(IConsole::ACCESS_LEVEL_ADMIN);
|
|
m_RconClientID = IServer::RCON_CID_SERV;
|
|
m_RconAuthLevel = AUTHED_ADMIN;
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_RCON_AUTH)
|
|
{
|
|
const char *pPw;
|
|
Unpacker.GetString(); // login name, not used
|
|
pPw = Unpacker.GetString(CUnpacker::SANITIZE_CC);
|
|
|
|
if(Unpacker.Error() == 0)
|
|
{
|
|
if(g_Config.m_SvRconPassword[0] == 0 && g_Config.m_SvRconModPassword[0] == 0)
|
|
{
|
|
SendRconLine(ClientID, "No rcon password set on server. Set sv_rcon_password and/or sv_rcon_mod_password to enable the remote console.");
|
|
}
|
|
else if(g_Config.m_SvRconPassword[0] && str_comp(pPw, g_Config.m_SvRconPassword) == 0)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_AUTH_STATUS);
|
|
Msg.AddInt(1); //authed
|
|
Msg.AddInt(1); //cmdlist
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true);
|
|
|
|
m_aClients[ClientID].m_Authed = AUTHED_ADMIN;
|
|
int SendRconCmds = Unpacker.GetInt();
|
|
if(Unpacker.Error() == 0 && SendRconCmds)
|
|
m_aClients[ClientID].m_pRconCmdToSend = Console()->FirstCommandInfo(IConsole::ACCESS_LEVEL_ADMIN, CFGFLAG_SERVER);
|
|
SendRconLine(ClientID, "Admin authentication successful. Full remote console access granted.");
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "ClientID=%d authed (admin)", ClientID);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
|
|
// DDRace
|
|
|
|
GameServer()->OnSetAuthed(ClientID, AUTHED_ADMIN);
|
|
}
|
|
else if(g_Config.m_SvRconModPassword[0] && str_comp(pPw, g_Config.m_SvRconModPassword) == 0)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_AUTH_STATUS);
|
|
Msg.AddInt(1); //authed
|
|
Msg.AddInt(1); //cmdlist
|
|
SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true);
|
|
|
|
m_aClients[ClientID].m_Authed = AUTHED_MOD;
|
|
int SendRconCmds = Unpacker.GetInt();
|
|
if(Unpacker.Error() == 0 && SendRconCmds)
|
|
m_aClients[ClientID].m_pRconCmdToSend = Console()->FirstCommandInfo(IConsole::ACCESS_LEVEL_MOD, CFGFLAG_SERVER);
|
|
SendRconLine(ClientID, "Moderator authentication successful. Limited remote console access granted.");
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "ClientID=%d authed (moderator)", ClientID);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
|
|
// DDRace
|
|
|
|
GameServer()->OnSetAuthed(ClientID, AUTHED_MOD);
|
|
}
|
|
else if(g_Config.m_SvRconMaxTries)
|
|
{
|
|
m_aClients[ClientID].m_AuthTries++;
|
|
char aBuf[128];
|
|
str_format(aBuf, sizeof(aBuf), "Wrong password %d/%d.", m_aClients[ClientID].m_AuthTries, g_Config.m_SvRconMaxTries);
|
|
SendRconLine(ClientID, aBuf);
|
|
if(m_aClients[ClientID].m_AuthTries >= g_Config.m_SvRconMaxTries)
|
|
{
|
|
if(!g_Config.m_SvRconBantime)
|
|
m_NetServer.Drop(ClientID, "Too many remote console authentication tries");
|
|
else
|
|
m_ServerBan.BanAddr(m_NetServer.ClientAddr(ClientID), g_Config.m_SvRconBantime*60, "Too many remote console authentication tries");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SendRconLine(ClientID, "Wrong password.");
|
|
}
|
|
}
|
|
}
|
|
else if(Msg == NETMSG_PING)
|
|
{
|
|
CMsgPacker Msg(NETMSG_PING_REPLY);
|
|
SendMsgEx(&Msg, 0, ClientID, true);
|
|
}
|
|
else
|
|
{
|
|
if(g_Config.m_Debug)
|
|
{
|
|
char aHex[] = "0123456789ABCDEF";
|
|
char aBuf[512];
|
|
|
|
for(int b = 0; b < pPacket->m_DataSize && b < 32; b++)
|
|
{
|
|
aBuf[b*3] = aHex[((const unsigned char *)pPacket->m_pData)[b]>>4];
|
|
aBuf[b*3+1] = aHex[((const unsigned char *)pPacket->m_pData)[b]&0xf];
|
|
aBuf[b*3+2] = ' ';
|
|
aBuf[b*3+3] = 0;
|
|
}
|
|
|
|
char aBufMsg[256];
|
|
str_format(aBufMsg, sizeof(aBufMsg), "strange message ClientID=%d msg=%d data_size=%d", ClientID, Msg, pPacket->m_DataSize);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBufMsg);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBuf);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// game message
|
|
if(m_aClients[ClientID].m_State >= CClient::STATE_READY)
|
|
GameServer()->OnMessage(Msg, &Unpacker, ClientID);
|
|
}
|
|
}
|
|
|
|
void CServer::SendServerInfo(const NETADDR *pAddr, int Token)
|
|
{
|
|
CNetChunk Packet;
|
|
CPacker p;
|
|
char aBuf[128];
|
|
|
|
// count the players
|
|
int PlayerCount = 0, ClientCount = 0;
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
if(m_aClients[i].m_State != CClient::STATE_EMPTY)
|
|
{
|
|
if(GameServer()->IsClientPlayer(i))
|
|
PlayerCount++;
|
|
|
|
ClientCount++;
|
|
}
|
|
}
|
|
|
|
p.Reset();
|
|
|
|
p.AddRaw(SERVERBROWSE_INFO, sizeof(SERVERBROWSE_INFO));
|
|
str_format(aBuf, sizeof(aBuf), "%d", Token);
|
|
p.AddString(aBuf, 6);
|
|
|
|
p.AddString(GameServer()->Version(), 32);
|
|
p.AddString(g_Config.m_SvName, 64);
|
|
p.AddString(GetMapName(), 32);
|
|
|
|
// gametype
|
|
p.AddString(GameServer()->GameType(), 16);
|
|
|
|
// flags
|
|
int i = 0;
|
|
if(g_Config.m_Password[0]) // password set
|
|
i |= SERVER_FLAG_PASSWORD;
|
|
str_format(aBuf, sizeof(aBuf), "%d", i);
|
|
p.AddString(aBuf, 2);
|
|
|
|
str_format(aBuf, sizeof(aBuf), "%d", PlayerCount); p.AddString(aBuf, 3); // num players
|
|
str_format(aBuf, sizeof(aBuf), "%d", max(m_NetServer.MaxClients()-g_Config.m_SvSpectatorSlots-g_Config.m_SvReservedSlots, PlayerCount)); p.AddString(aBuf, 3); // max players
|
|
str_format(aBuf, sizeof(aBuf), "%d", ClientCount); p.AddString(aBuf, 3); // num clients
|
|
str_format(aBuf, sizeof(aBuf), "%d", max(m_NetServer.MaxClients()-g_Config.m_SvReservedSlots, ClientCount)); p.AddString(aBuf, 3); // max clients
|
|
|
|
for(i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
if(m_aClients[i].m_State != CClient::STATE_EMPTY)
|
|
{
|
|
p.AddString(ClientName(i), MAX_NAME_LENGTH); // client name
|
|
p.AddString(ClientClan(i), MAX_CLAN_LENGTH); // client clan
|
|
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Country); p.AddString(aBuf, 6); // client country
|
|
str_format(aBuf, sizeof(aBuf), "%d", m_aClients[i].m_Score); p.AddString(aBuf, 6); // client score
|
|
str_format(aBuf, sizeof(aBuf), "%d", GameServer()->IsClientPlayer(i)?1:0); p.AddString(aBuf, 2); // is player?
|
|
}
|
|
}
|
|
|
|
Packet.m_ClientID = -1;
|
|
Packet.m_Address = *pAddr;
|
|
Packet.m_Flags = NETSENDFLAG_CONNLESS;
|
|
Packet.m_DataSize = p.Size();
|
|
Packet.m_pData = p.Data();
|
|
m_NetServer.Send(&Packet);
|
|
}
|
|
|
|
void CServer::UpdateServerInfo()
|
|
{
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(m_aClients[i].m_State != CClient::STATE_EMPTY)
|
|
SendServerInfo(m_NetServer.ClientAddr(i), -1);
|
|
}
|
|
}
|
|
|
|
|
|
void CServer::PumpNetwork()
|
|
{
|
|
CNetChunk Packet;
|
|
|
|
m_NetServer.Update();
|
|
|
|
// process packets
|
|
while(m_NetServer.Recv(&Packet))
|
|
{
|
|
if(Packet.m_ClientID == -1)
|
|
{
|
|
// stateless
|
|
if(!m_Register.RegisterProcessPacket(&Packet))
|
|
{
|
|
if(Packet.m_DataSize == sizeof(SERVERBROWSE_GETINFO)+1 &&
|
|
mem_comp(Packet.m_pData, SERVERBROWSE_GETINFO, sizeof(SERVERBROWSE_GETINFO)) == 0)
|
|
{
|
|
SendServerInfo(&Packet.m_Address, ((unsigned char *)Packet.m_pData)[sizeof(SERVERBROWSE_GETINFO)]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ProcessClientPacket(&Packet);
|
|
}
|
|
if(g_Config.m_SvFastDownload)
|
|
{
|
|
for (int i=0;i<MAX_CLIENTS;i++)
|
|
{
|
|
if (m_aClients[i].m_State != CClient::STATE_CONNECTING)
|
|
continue;
|
|
if (lastasktick[i] < Tick()-TickSpeed())
|
|
{
|
|
lastsent[i] = lastask[i];
|
|
lastasktick[i] = Tick();
|
|
}
|
|
if (lastask[i]<lastsent[i]-g_Config.m_SvMapWindow)
|
|
continue;
|
|
|
|
int Chunk = lastsent[i]++;
|
|
int ChunkSize = 1024-128;
|
|
int Offset = Chunk * ChunkSize;
|
|
int Last = 0;
|
|
|
|
// drop faulty map data requests
|
|
if(Chunk < 0 || Offset > m_CurrentMapSize)
|
|
continue;
|
|
if(Offset+ChunkSize >= m_CurrentMapSize)
|
|
{
|
|
ChunkSize = m_CurrentMapSize-Offset;
|
|
if(ChunkSize < 0)
|
|
ChunkSize = 0;
|
|
Last = 1;
|
|
}
|
|
|
|
CMsgPacker Msg(NETMSG_MAP_DATA);
|
|
Msg.AddInt(Last);
|
|
Msg.AddInt(m_CurrentMapCrc);
|
|
Msg.AddInt(Chunk);
|
|
Msg.AddInt(ChunkSize);
|
|
Msg.AddRaw(&m_pCurrentMapData[Offset], ChunkSize);
|
|
SendMsgEx(&Msg, MSGFLAG_FLUSH, i, true);
|
|
|
|
if(g_Config.m_Debug)
|
|
{
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "sending chunk %d with size %d", Chunk, ChunkSize);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBuf);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_ServerBan.Update();
|
|
m_Econ.Update();
|
|
}
|
|
|
|
char *CServer::GetMapName()
|
|
{
|
|
// get the name of the map without his path
|
|
char *pMapShortName = &g_Config.m_SvMap[0];
|
|
for(int i = 0; i < str_length(g_Config.m_SvMap)-1; i++)
|
|
{
|
|
if(g_Config.m_SvMap[i] == '/' || g_Config.m_SvMap[i] == '\\')
|
|
pMapShortName = &g_Config.m_SvMap[i+1];
|
|
}
|
|
return pMapShortName;
|
|
}
|
|
|
|
int CServer::LoadMap(const char *pMapName)
|
|
{
|
|
//DATAFILE *df;
|
|
char aBuf[512];
|
|
str_format(aBuf, sizeof(aBuf), "maps/%s.map", pMapName);
|
|
|
|
/*df = datafile_load(buf);
|
|
if(!df)
|
|
return 0;*/
|
|
|
|
// check for valid standard map
|
|
if(!m_MapChecker.ReadAndValidateMap(Storage(), aBuf, IStorage::TYPE_ALL))
|
|
{
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "mapchecker", "invalid standard map");
|
|
return 0;
|
|
}
|
|
|
|
if(!m_pMap->Load(aBuf))
|
|
return 0;
|
|
|
|
// stop recording when we change map
|
|
m_DemoRecorder.Stop();
|
|
|
|
// reinit snapshot ids
|
|
m_IDPool.TimeoutIDs();
|
|
|
|
// get the crc of the map
|
|
m_CurrentMapCrc = m_pMap->Crc();
|
|
char aBufMsg[256];
|
|
str_format(aBufMsg, sizeof(aBufMsg), "%s crc is %08x", aBuf, m_CurrentMapCrc);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBufMsg);
|
|
|
|
str_copy(m_aCurrentMap, pMapName, sizeof(m_aCurrentMap));
|
|
//map_set(df);
|
|
|
|
// load complete map into memory for download
|
|
{
|
|
IOHANDLE File = Storage()->OpenFile(aBuf, IOFLAG_READ, IStorage::TYPE_ALL);
|
|
m_CurrentMapSize = (int)io_length(File);
|
|
if(m_pCurrentMapData)
|
|
mem_free(m_pCurrentMapData);
|
|
m_pCurrentMapData = (unsigned char *)mem_alloc(m_CurrentMapSize, 1);
|
|
io_read(File, m_pCurrentMapData, m_CurrentMapSize);
|
|
io_close(File);
|
|
}
|
|
|
|
for(int i=0; i<MAX_CLIENTS; i++)
|
|
m_aPrevStates[i] = m_aClients[i].m_State;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CServer::InitRegister(CNetServer *pNetServer, IEngineMasterServer *pMasterServer, IConsole *pConsole)
|
|
{
|
|
m_Register.Init(pNetServer, pMasterServer, pConsole);
|
|
}
|
|
|
|
int CServer::Run()
|
|
{
|
|
//
|
|
m_PrintCBIndex = Console()->RegisterPrintCallback(g_Config.m_ConsoleOutputLevel, SendRconLineAuthed, this);
|
|
|
|
// load map
|
|
if(!LoadMap(g_Config.m_SvMap))
|
|
{
|
|
dbg_msg("server", "failed to load map. mapname='%s'", g_Config.m_SvMap);
|
|
return -1;
|
|
}
|
|
|
|
// start server
|
|
NETADDR BindAddr;
|
|
if(g_Config.m_Bindaddr[0] && net_host_lookup(g_Config.m_Bindaddr, &BindAddr, NETTYPE_ALL) == 0)
|
|
{
|
|
// sweet!
|
|
BindAddr.port = g_Config.m_SvPort;
|
|
}
|
|
else
|
|
{
|
|
mem_zero(&BindAddr, sizeof(BindAddr));
|
|
BindAddr.type = NETTYPE_ALL;
|
|
BindAddr.port = g_Config.m_SvPort;
|
|
}
|
|
|
|
if(!m_NetServer.Open(BindAddr, &m_ServerBan, g_Config.m_SvMaxClients, g_Config.m_SvMaxClientsPerIP, 0))
|
|
{
|
|
dbg_msg("server", "couldn't open socket. port %d might already be in use", g_Config.m_SvPort);
|
|
return -1;
|
|
}
|
|
|
|
m_NetServer.SetCallbacks(NewClientCallback, DelClientCallback, this);
|
|
|
|
m_Econ.Init(Console(), &m_ServerBan);
|
|
|
|
char aBuf[256];
|
|
str_format(aBuf, sizeof(aBuf), "server name is '%s'", g_Config.m_SvName);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
|
|
GameServer()->OnInit();
|
|
str_format(aBuf, sizeof(aBuf), "version %s", GameServer()->NetVersion());
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
|
|
// process pending commands
|
|
m_pConsole->StoreCommands(false);
|
|
|
|
// start game
|
|
{
|
|
int64 ReportTime = time_get();
|
|
int ReportInterval = 3;
|
|
|
|
m_Lastheartbeat = 0;
|
|
m_GameStartTime = time_get();
|
|
|
|
if(g_Config.m_Debug)
|
|
{
|
|
str_format(aBuf, sizeof(aBuf), "baseline memory usage %dk", mem_stats()->allocated/1024);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBuf);
|
|
}
|
|
|
|
while(m_RunServer)
|
|
{
|
|
int64 t = time_get();
|
|
int NewTicks = 0;
|
|
|
|
// load new map TODO: don't poll this
|
|
if(str_comp(g_Config.m_SvMap, m_aCurrentMap) != 0 || m_MapReload)
|
|
{
|
|
m_MapReload = 0;
|
|
|
|
// load map
|
|
if(LoadMap(g_Config.m_SvMap))
|
|
{
|
|
// new map loaded
|
|
GameServer()->OnShutdown();
|
|
|
|
for(int c = 0; c < MAX_CLIENTS; c++)
|
|
{
|
|
if(m_aClients[c].m_State <= CClient::STATE_AUTH)
|
|
continue;
|
|
|
|
SendMap(c);
|
|
m_aClients[c].Reset();
|
|
m_aClients[c].m_State = CClient::STATE_CONNECTING;
|
|
}
|
|
|
|
m_GameStartTime = time_get();
|
|
m_CurrentGameTick = 0;
|
|
Kernel()->ReregisterInterface(GameServer());
|
|
GameServer()->OnInit();
|
|
UpdateServerInfo();
|
|
}
|
|
else
|
|
{
|
|
str_format(aBuf, sizeof(aBuf), "failed to load map. mapname='%s'", g_Config.m_SvMap);
|
|
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
str_copy(g_Config.m_SvMap, m_aCurrentMap, sizeof(g_Config.m_SvMap));
|
|
}
|
|
}
|
|
|
|
while(t > TickStartTime(m_CurrentGameTick+1))
|
|
{
|
|
m_CurrentGameTick++;
|
|
NewTicks++;
|
|
|
|
// apply new input
|
|
for(int c = 0; c < MAX_CLIENTS; c++)
|
|
{
|
|
if(m_aClients[c].m_State == CClient::STATE_EMPTY)
|
|
continue;
|
|
for(int i = 0; i < 200; i++)
|
|
{
|
|
if(m_aClients[c].m_aInputs[i].m_GameTick == Tick())
|
|
{
|
|
if(m_aClients[c].m_State == CClient::STATE_INGAME)
|
|
GameServer()->OnClientPredictedInput(c, m_aClients[c].m_aInputs[i].m_aData);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
GameServer()->OnTick();
|
|
}
|
|
|
|
// snap game
|
|
if(NewTicks)
|
|
{
|
|
if(g_Config.m_SvHighBandwidth || (m_CurrentGameTick%2) == 0)
|
|
DoSnapshot();
|
|
|
|
UpdateClientRconCommands();
|
|
}
|
|
|
|
// master server stuff
|
|
m_Register.RegisterUpdate(m_NetServer.NetType());
|
|
|
|
PumpNetwork();
|
|
|
|
if(ReportTime < time_get())
|
|
{
|
|
if(g_Config.m_Debug)
|
|
{
|
|
/*
|
|
static NETSTATS prev_stats;
|
|
NETSTATS stats;
|
|
netserver_stats(net, &stats);
|
|
|
|
perf_next();
|
|
|
|
if(config.dbg_pref)
|
|
perf_dump(&rootscope);
|
|
|
|
dbg_msg("server", "send=%8d recv=%8d",
|
|
(stats.send_bytes - prev_stats.send_bytes)/reportinterval,
|
|
(stats.recv_bytes - prev_stats.recv_bytes)/reportinterval);
|
|
|
|
prev_stats = stats;
|
|
*/
|
|
}
|
|
|
|
ReportTime += time_freq()*ReportInterval;
|
|
}
|
|
|
|
// wait for incomming data
|
|
net_socket_read_wait(m_NetServer.Socket(), 5);
|
|
}
|
|
}
|
|
// disconnect all clients on shutdown
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(m_aClients[i].m_State != CClient::STATE_EMPTY)
|
|
m_NetServer.Drop(i, "Server shutdown");
|
|
|
|
m_Econ.Shutdown();
|
|
}
|
|
|
|
GameServer()->OnShutdown();
|
|
m_pMap->Unload();
|
|
|
|
if(m_pCurrentMapData)
|
|
mem_free(m_pCurrentMapData);
|
|
return 0;
|
|
}
|
|
|
|
void CServer::ConTestingCommands(CConsole::IResult *pResult, void *pUser)
|
|
{
|
|
char aBuf[128];
|
|
str_format(aBuf, sizeof(aBuf), "Value: %d", g_Config.m_SvTestingCommands);
|
|
((CConsole*)pUser)->Print(CConsole::OUTPUT_LEVEL_STANDARD, "Console", aBuf);
|
|
}
|
|
|
|
void CServer::ConKick(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
if(pResult->NumArguments() > 1)
|
|
{
|
|
char aBuf[128];
|
|
str_format(aBuf, sizeof(aBuf), "Kicked (%s)", pResult->GetString(1));
|
|
((CServer *)pUser)->Kick(pResult->GetInteger(0), aBuf);
|
|
}
|
|
else
|
|
((CServer *)pUser)->Kick(pResult->GetInteger(0), "Kicked by console");
|
|
}
|
|
|
|
void CServer::ConStatus(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
char aBuf[1024];
|
|
char aAddrStr[NETADDR_MAXSTRSIZE];
|
|
CServer* pThis = static_cast<CServer *>(pUser);
|
|
|
|
for(int i = 0; i < MAX_CLIENTS; i++)
|
|
{
|
|
if(pThis->m_aClients[i].m_State != CClient::STATE_EMPTY)
|
|
{
|
|
net_addr_str(pThis->m_NetServer.ClientAddr(i), aAddrStr, sizeof(aAddrStr), true);
|
|
if(pThis->m_aClients[i].m_State == CClient::STATE_INGAME)
|
|
str_format(aBuf, sizeof(aBuf), "id=%d addr=%s name='%s' score=%d", i, aAddrStr,
|
|
pThis->m_aClients[i].m_aName, pThis->m_aClients[i].m_Score);
|
|
else
|
|
str_format(aBuf, sizeof(aBuf), "id=%d addr=%s connecting", i, aAddrStr);
|
|
pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "Server", aBuf);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CServer::ConShutdown(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
((CServer *)pUser)->m_RunServer = 0;
|
|
}
|
|
|
|
void CServer::DemoRecorder_HandleAutoStart()
|
|
{
|
|
if(g_Config.m_SvAutoDemoRecord)
|
|
{
|
|
m_DemoRecorder.Stop();
|
|
char aFilename[128];
|
|
char aDate[20];
|
|
str_timestamp(aDate, sizeof(aDate));
|
|
str_format(aFilename, sizeof(aFilename), "demos/%s_%s.demo", "auto/autorecord", aDate);
|
|
m_DemoRecorder.Start(Storage(), m_pConsole, aFilename, GameServer()->NetVersion(), m_aCurrentMap, m_CurrentMapCrc, "server");
|
|
if(g_Config.m_SvAutoDemoMax)
|
|
{
|
|
// clean up auto recorded demos
|
|
CFileCollection AutoDemos;
|
|
AutoDemos.Init(Storage(), "demos/server", "autorecord", ".demo", g_Config.m_SvAutoDemoMax);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CServer::DemoRecorder_IsRecording()
|
|
{
|
|
return m_DemoRecorder.IsRecording();
|
|
}
|
|
|
|
void CServer::ConRecord(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
CServer* pServer = (CServer *)pUser;
|
|
char aFilename[128];
|
|
|
|
if(pResult->NumArguments())
|
|
str_format(aFilename, sizeof(aFilename), "demos/%s.demo", pResult->GetString(0));
|
|
else
|
|
{
|
|
char aDate[20];
|
|
str_timestamp(aDate, sizeof(aDate));
|
|
str_format(aFilename, sizeof(aFilename), "demos/demo_%s.demo", aDate);
|
|
}
|
|
pServer->m_DemoRecorder.Start(pServer->Storage(), pServer->Console(), aFilename, pServer->GameServer()->NetVersion(), pServer->m_aCurrentMap, pServer->m_CurrentMapCrc, "server");
|
|
}
|
|
|
|
void CServer::ConStopRecord(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
((CServer *)pUser)->m_DemoRecorder.Stop();
|
|
}
|
|
|
|
void CServer::ConMapReload(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
((CServer *)pUser)->m_MapReload = 1;
|
|
}
|
|
|
|
void CServer::ConLogout(IConsole::IResult *pResult, void *pUser)
|
|
{
|
|
CServer *pServer = (CServer *)pUser;
|
|
|
|
if(pServer->m_RconClientID >= 0 && pServer->m_RconClientID < MAX_CLIENTS &&
|
|
pServer->m_aClients[pServer->m_RconClientID].m_State != CServer::CClient::STATE_EMPTY)
|
|
{
|
|
CMsgPacker Msg(NETMSG_RCON_AUTH_STATUS);
|
|
Msg.AddInt(0); //authed
|
|
Msg.AddInt(0); //cmdlist
|
|
pServer->SendMsgEx(&Msg, MSGFLAG_VITAL, pServer->m_RconClientID, true);
|
|
|
|
pServer->m_aClients[pServer->m_RconClientID].m_Authed = AUTHED_NO;
|
|
pServer->m_aClients[pServer->m_RconClientID].m_pRconCmdToSend = 0;
|
|
pServer->SendRconLine(pServer->m_RconClientID, "Logout successful.");
|
|
char aBuf[32];
|
|
str_format(aBuf, sizeof(aBuf), "ClientID=%d logged out", pServer->m_RconClientID);
|
|
pServer->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
|
|
}
|
|
}
|
|
|
|
void CServer::ConchainSpecialInfoupdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData)
|
|
{
|
|
pfnCallback(pResult, pCallbackUserData);
|
|
if(pResult->NumArguments())
|
|
((CServer *)pUserData)->UpdateServerInfo();
|
|
}
|
|
|
|
void CServer::ConchainMaxclientsperipUpdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData)
|
|
{
|
|
pfnCallback(pResult, pCallbackUserData);
|
|
if(pResult->NumArguments())
|
|
((CServer *)pUserData)->m_NetServer.SetMaxClientsPerIP(pResult->GetInteger(0));
|
|
}
|
|
|
|
void CServer::ConchainModCommandUpdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData)
|
|
{
|
|
if(pResult->NumArguments() == 2)
|
|
{
|
|
CServer *pThis = static_cast<CServer *>(pUserData);
|
|
const IConsole::CCommandInfo *pInfo = pThis->Console()->GetCommandInfo(pResult->GetString(0), CFGFLAG_SERVER, false);
|
|
int OldAccessLevel = 0;
|
|
if(pInfo)
|
|
OldAccessLevel = pInfo->GetAccessLevel();
|
|
pfnCallback(pResult, pCallbackUserData);
|
|
if(pInfo && OldAccessLevel != pInfo->GetAccessLevel())
|
|
{
|
|
for(int i = 0; i < MAX_CLIENTS; ++i)
|
|
{
|
|
if(pThis->m_aClients[i].m_State == CServer::CClient::STATE_EMPTY || pThis->m_aClients[i].m_Authed != CServer::AUTHED_MOD ||
|
|
(pThis->m_aClients[i].m_pRconCmdToSend && str_comp(pResult->GetString(0), pThis->m_aClients[i].m_pRconCmdToSend->m_pName) >= 0))
|
|
continue;
|
|
|
|
if(OldAccessLevel == IConsole::ACCESS_LEVEL_ADMIN)
|
|
pThis->SendRconCmdAdd(pInfo, i);
|
|
else
|
|
pThis->SendRconCmdRem(pInfo, i);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
pfnCallback(pResult, pCallbackUserData);
|
|
}
|
|
|
|
void CServer::ConchainConsoleOutputLevelUpdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData)
|
|
{
|
|
pfnCallback(pResult, pCallbackUserData);
|
|
if(pResult->NumArguments() == 1)
|
|
{
|
|
CServer *pThis = static_cast<CServer *>(pUserData);
|
|
pThis->Console()->SetPrintOutputLevel(pThis->m_PrintCBIndex, pResult->GetInteger(0));
|
|
}
|
|
}
|
|
|
|
void CServer::RegisterCommands()
|
|
{
|
|
m_pConsole = Kernel()->RequestInterface<IConsole>();
|
|
m_pGameServer = Kernel()->RequestInterface<IGameServer>();
|
|
m_pMap = Kernel()->RequestInterface<IEngineMap>();
|
|
m_pStorage = Kernel()->RequestInterface<IStorage>();
|
|
|
|
// register console commands
|
|
Console()->Register("kick", "i?r", CFGFLAG_SERVER, ConKick, this, "Kick player with specified id for any reason");
|
|
Console()->Register("status", "", CFGFLAG_SERVER, ConStatus, this, "List players");
|
|
Console()->Register("shutdown", "", CFGFLAG_SERVER, ConShutdown, this, "Shut down");
|
|
Console()->Register("logout", "", CFGFLAG_SERVER, ConLogout, this, "Logout of rcon");
|
|
|
|
Console()->Register("record", "?s", CFGFLAG_SERVER|CFGFLAG_STORE, ConRecord, this, "Record to a file");
|
|
Console()->Register("stoprecord", "", CFGFLAG_SERVER, ConStopRecord, this, "Stop recording");
|
|
|
|
Console()->Register("reload", "", CFGFLAG_SERVER, ConMapReload, this, "Reload the map");
|
|
|
|
Console()->Chain("sv_name", ConchainSpecialInfoupdate, this);
|
|
Console()->Chain("password", ConchainSpecialInfoupdate, this);
|
|
|
|
Console()->Chain("sv_max_clients_per_ip", ConchainMaxclientsperipUpdate, this);
|
|
Console()->Chain("mod_command", ConchainModCommandUpdate, this);
|
|
Console()->Chain("console_output_level", ConchainConsoleOutputLevelUpdate, this);
|
|
|
|
// register console commands in sub parts
|
|
m_ServerBan.Init(Console(), Storage(), this);
|
|
m_pGameServer->OnConsoleInit();
|
|
}
|
|
|
|
|
|
int CServer::SnapNewID()
|
|
{
|
|
return m_IDPool.NewID();
|
|
}
|
|
|
|
void CServer::SnapFreeID(int ID)
|
|
{
|
|
m_IDPool.FreeID(ID);
|
|
}
|
|
|
|
|
|
void *CServer::SnapNewItem(int Type, int ID, int Size)
|
|
{
|
|
dbg_assert(Type >= 0 && Type <=0xffff, "incorrect type");
|
|
dbg_assert(ID >= 0 && ID <=0xffff, "incorrect id");
|
|
return ID < 0 ? 0 : m_SnapshotBuilder.NewItem(Type, ID, Size);
|
|
}
|
|
|
|
void CServer::SnapSetStaticsize(int ItemType, int Size)
|
|
{
|
|
m_SnapshotDelta.SetStaticsize(ItemType, Size);
|
|
}
|
|
|
|
static CServer *CreateServer() { return new CServer(); }
|
|
|
|
int main(int argc, const char **argv) // ignore_convention
|
|
{
|
|
#if defined(CONF_FAMILY_WINDOWS)
|
|
for(int i = 1; i < argc; i++) // ignore_convention
|
|
{
|
|
if(str_comp("-s", argv[i]) == 0 || str_comp("--silent", argv[i]) == 0) // ignore_convention
|
|
{
|
|
ShowWindow(GetConsoleWindow(), SW_HIDE);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
CServer *pServer = CreateServer();
|
|
IKernel *pKernel = IKernel::Create();
|
|
|
|
// create the components
|
|
IEngine *pEngine = CreateEngine("Teeworlds");
|
|
IEngineMap *pEngineMap = CreateEngineMap();
|
|
IGameServer *pGameServer = CreateGameServer();
|
|
IConsole *pConsole = CreateConsole(CFGFLAG_SERVER|CFGFLAG_ECON);
|
|
IEngineMasterServer *pEngineMasterServer = CreateEngineMasterServer();
|
|
IStorage *pStorage = CreateStorage("Teeworlds", IStorage::STORAGETYPE_SERVER, argc, argv); // ignore_convention
|
|
IConfig *pConfig = CreateConfig();
|
|
|
|
pServer->InitRegister(&pServer->m_NetServer, pEngineMasterServer, pConsole);
|
|
|
|
{
|
|
bool RegisterFail = false;
|
|
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pServer); // register as both
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pEngine);
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast<IEngineMap*>(pEngineMap)); // register as both
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast<IMap*>(pEngineMap));
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pGameServer);
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pConsole);
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pStorage);
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(pConfig);
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast<IEngineMasterServer*>(pEngineMasterServer)); // register as both
|
|
RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast<IMasterServer*>(pEngineMasterServer));
|
|
|
|
if(RegisterFail)
|
|
return -1;
|
|
}
|
|
|
|
pEngine->Init();
|
|
pConfig->Init();
|
|
pEngineMasterServer->Init();
|
|
pEngineMasterServer->Load();
|
|
|
|
// register all console commands
|
|
pServer->RegisterCommands();
|
|
|
|
// execute autoexec file
|
|
pConsole->ExecuteFile("autoexec.cfg");
|
|
|
|
// parse the command line arguments
|
|
if(argc > 1) // ignore_convention
|
|
pConsole->ParseArguments(argc-1, &argv[1]); // ignore_convention
|
|
|
|
pConsole->Register("sv_test_cmds", "", CFGFLAG_SERVER|CFGFLAG_CLIENT, CServer::ConTestingCommands, pConsole, "Turns testing commands aka cheats on/off");
|
|
|
|
// restore empty config strings to their defaults
|
|
pConfig->RestoreStrings();
|
|
|
|
pEngine->InitLogfile();
|
|
|
|
FifoConsole *fifoConsole = new FifoConsole(pConsole);
|
|
|
|
// run the server
|
|
dbg_msg("server", "starting...");
|
|
pServer->Run();
|
|
|
|
// free
|
|
delete fifoConsole;
|
|
delete pServer;
|
|
delete pKernel;
|
|
delete pEngineMap;
|
|
delete pGameServer;
|
|
delete pConsole;
|
|
delete pEngineMasterServer;
|
|
delete pStorage;
|
|
delete pConfig;
|
|
return 0;
|
|
}
|
|
|
|
// DDRace
|
|
|
|
void CServer::GetClientAddr(int ClientID, NETADDR *pAddr)
|
|
{
|
|
if(ClientID >= 0 && ClientID < MAX_CLIENTS && m_aClients[ClientID].m_State == CClient::STATE_INGAME) {
|
|
*pAddr = *m_NetServer.ClientAddr(ClientID);
|
|
}
|
|
}
|
|
|
|
char *CServer::GetAnnouncementLine(char const *pFileName)
|
|
{
|
|
IOHANDLE File = m_pStorage->OpenFile(pFileName, IOFLAG_READ, IStorage::TYPE_ALL);
|
|
if(File)
|
|
{
|
|
std::vector<char*> v;
|
|
char *pLine;
|
|
CLineReader *lr = new CLineReader();
|
|
lr->Init(File);
|
|
while((pLine = lr->Get()))
|
|
if(str_length(pLine))
|
|
if(pLine[0]!='#')
|
|
v.push_back(pLine);
|
|
if(v.size() == 1)
|
|
{
|
|
m_AnnouncementLastLine = 0;
|
|
}
|
|
else if(!g_Config.m_SvAnnouncementRandom)
|
|
{
|
|
if(m_AnnouncementLastLine >= v.size())
|
|
m_AnnouncementLastLine %= v.size();
|
|
}
|
|
else
|
|
{
|
|
unsigned Rand;
|
|
do
|
|
Rand = rand() % v.size();
|
|
while(Rand == m_AnnouncementLastLine);
|
|
|
|
m_AnnouncementLastLine = Rand;
|
|
}
|
|
return v[m_AnnouncementLastLine];
|
|
}
|
|
return 0;
|
|
}
|
|
|