/* (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. */ #define _WIN32_WINNT 0x0501 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // DDRace #include #include #include #include #include "register.h" #include "server.h" #if defined(CONF_FAMILY_WINDOWS) #define WIN32_LEAN_AND_MEAN #include #endif static const char *StrLtrim(const char *pStr) { while(*pStr) { const char *pStrOld = pStr; int Code = str_utf8_decode(&pStr); // check if unicode is not empty if(str_utf8_isspace(Code)) { return pStrOld; } } return pStr; } static void StrRtrim(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(str_utf8_isspace(Code)) { pEnd = 0; } else if(pEnd == 0) pEnd = pStrOld; } if(pEnd != 0) *(const_cast(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::InitServerBan(IConsole *pConsole, IStorage *pStorage, CServer *pServer) { CNetBan::Init(pConsole, pStorage); m_pServer = pServer; // overwrites base command, todo: improve this Console()->Register("ban", "s[ip|id] ?i[minutes] r[reason]", CFGFLAG_SERVER|CFGFLAG_STORE, ConBanExt, this, "Ban player with ip/client id for x minutes for any reason"); } template 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(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; m_NextMapChunk = 0; } CServer::CServer() { for(int i = 0; i < MAX_CLIENTS; i++) m_aDemoRecorder[i] = CDemoRecorder(&m_SnapshotDelta, true); m_aDemoRecorder[MAX_CLIENTS] = CDemoRecorder(&m_SnapshotDelta, false); m_TickSpeed = SERVER_TICK_SPEED; m_pGameServer = 0; m_CurrentGameTick = 0; m_RunServer = 1; m_pCurrentMapData = 0; m_CurrentMapSize = 0; m_MapReload = 0; m_ReloadedWhenEmpty = false; m_RconClientID = IServer::RCON_CID_SERV; m_RconAuthLevel = AUTHED_ADMIN; m_RconRestrict = -1; m_ServerInfoFirstRequest = 0; m_ServerInfoNumRequests = 0; m_ServerInfoHighLoad = false; #if defined (CONF_SQL) for (int i = 0; i < MAX_SQLSERVERS; i++) { m_apSqlReadServers[i] = 0; m_apSqlWriteServers[i] = 0; } CSqlConnector::SetReadServers(m_apSqlReadServers); CSqlConnector::SetWriteServers(m_apSqlWriteServers); #endif Init(); } int CServer::TrySetClientName(int ClientID, const char *pName) { char aTrimmedName[64]; // trim the name str_copy(aTrimmedName, StrLtrim(pName), sizeof(aTrimmedName)); StrRtrim(aTrimmedName); // check for empty names if(!aTrimmedName[0]) return -1; // check for names starting with /, as they can be abused to make people // write chat commands if(aTrimmedName[0] == '/') return -1; // make sure that two clients don'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_utf8_comp_confusable(aTrimmedName, m_aClients[i].m_aName) == 0) return -1; } } char aBuf[256]; str_format(aBuf, sizeof(aBuf), "'%s' -> '%s'", pName, aTrimmedName); Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "server", aBuf); pName = aTrimmedName; // 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, sizeof(aNameTry)); if(TrySetClientName(ClientID, aNameTry)) { // auto rename for(int i = 1;; i++) { str_format(aNameTry, sizeof(aNameTry), "(%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_aClients[i].m_AuthKey = -1; } 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; } int CServer::GetAuthedState(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; pInfo->m_ClientVersion = GameServer()->GetClientVersion(ClientID); 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)) { if(ClientID > -1) m_aDemoRecorder[ClientID].RecordMessage(pMsg->Data(), pMsg->Size()); m_aDemoRecorder[MAX_CLIENTS].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_aDemoRecorder[MAX_CLIENTS].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); // for antiping: if the projectile netobjects contains extra data, this is removed and the original content restored before recording demo unsigned char aExtraInfoRemoved[CSnapshot::MAX_SIZE]; mem_copy(aExtraInfoRemoved, aData, SnapshotSize); SnapshotRemoveExtraInfo(aExtraInfoRemoved); // write snapshot m_aDemoRecorder[MAX_CLIENTS].RecordSnapshot(Tick(), aExtraInfoRemoved, 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); if(m_aDemoRecorder[i].IsRecording()) { // for antiping: if the projectile netobjects contains extra data, this is removed and the original content restored before recording demo unsigned char aExtraInfoRemoved[CSnapshot::MAX_SIZE]; mem_copy(aExtraInfoRemoved, aData, SnapshotSize); SnapshotRemoveExtraInfo(aExtraInfoRemoved); // write snapshot m_aDemoRecorder[i].RecordSnapshot(Tick(), aExtraInfoRemoved, SnapshotSize); } 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, sizeof(aCompData)); NumPackets = (SnapshotSize+MaxSize-1)/MaxSize; for(int n = 0, Left = SnapshotSize; Left > 0; 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::ClientRejoinCallback(int ClientID, void *pUser) { CServer *pThis = (CServer *)pUser; pThis->m_aClients[ClientID].m_Authed = AUTHED_NO; pThis->m_aClients[ClientID].m_AuthKey = -1; pThis->m_aClients[ClientID].m_pRconCmdToSend = 0; pThis->m_aClients[ClientID].Reset(); pThis->SendMap(ClientID); return 0; } int CServer::NewClientNoAuthCallback(int ClientID, bool Reset, void *pUser) { CServer *pThis = (CServer *)pUser; pThis->m_aClients[ClientID].m_DnsblState = CClient::DNSBL_STATE_NONE; if (Reset) { pThis->m_aClients[ClientID].m_State = CClient::STATE_CONNECTING; 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_AuthKey = -1; pThis->m_aClients[ClientID].m_AuthTries = 0; pThis->m_aClients[ClientID].m_pRconCmdToSend = 0; pThis->m_aClients[ClientID].Reset(); } pThis->SendMap(ClientID); return 0; } 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_DnsblState = CClient::DNSBL_STATE_NONE; 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_AuthKey = -1; pThis->m_aClients[ClientID].m_AuthTries = 0; pThis->m_aClients[ClientID].m_pRconCmdToSend = 0; pThis->m_aClients[ClientID].m_Traffic = 0; pThis->m_aClients[ClientID].m_TrafficSince = 0; memset(&pThis->m_aClients[ClientID].m_Addr, 0, sizeof(NETADDR)); pThis->m_aClients[ClientID].Reset(); return 0; } void CServer::InitDnsbl(int ClientID) { NETADDR Addr = *m_NetServer.ClientAddr(ClientID); //TODO: support ipv6 if (Addr.type != NETTYPE_IPV4) return; // build dnsbl host lookup char aBuf[256]; if (g_Config.m_SvDnsblKey[0] == '\0') // without key str_format(aBuf, sizeof(aBuf), "%d.%d.%d.%d.%s", Addr.ip[3], Addr.ip[2], Addr.ip[1], Addr.ip[0], g_Config.m_SvDnsblHost); else // with key str_format(aBuf, sizeof(aBuf), "%s.%d.%d.%d.%d.%s", g_Config.m_SvDnsblKey, Addr.ip[3], Addr.ip[2], Addr.ip[1], Addr.ip[0], g_Config.m_SvDnsblHost); IEngine *pEngine = Kernel()->RequestInterface(); pEngine->HostLookup(&m_aClients[ClientID].m_DnsblLookup, aBuf, NETTYPE_IPV4); } 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_AuthKey = -1; pThis->m_aClients[ClientID].m_AuthTries = 0; pThis->m_aClients[ClientID].m_pRconCmdToSend = 0; pThis->m_aClients[ClientID].m_Traffic = 0; pThis->m_aClients[ClientID].m_TrafficSince = 0; pThis->m_aPrevStates[ClientID] = CClient::STATE_EMPTY; pThis->m_aClients[ClientID].m_Snapshots.PurgeAll(); return 0; } void CServer::SendRconType(int ClientID, bool UsernameReq) { CMsgPacker Msg(NETMSG_RCONTYPE); Msg.AddInt(UsernameReq); SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true); } void CServer::GetMapInfo(char *pMapName, int MapNameSize, int *pMapSize, int *pMapCrc) { str_copy(pMapName, GetMapName(), MapNameSize); *pMapSize = m_CurrentMapSize; *pMapCrc = m_CurrentMapCrc; } void CServer::SendMap(int ClientID) { 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); m_aClients[ClientID].m_NextMapChunk = 0; } void CServer::SendMapData(int ClientID, int Chunk) { unsigned int ChunkSize = 1024-128; unsigned int Offset = Chunk * ChunkSize; int Last = 0; // drop faulty map data requests if(Chunk < 0 || Offset > m_CurrentMapSize) return; if(Offset+ChunkSize >= m_CurrentMapSize) { ChunkSize = m_CurrentMapSize-Offset; 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_VITAL|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); } } 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, bool Highlighted) { 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 : m_aClients[ClientID].m_Authed == AUTHED_MOD ? IConsole::ACCESS_LEVEL_MOD : IConsole::ACCESS_LEVEL_HELPER; 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); CMsgPacker Packer(NETMSG_EX); // unpack msgid and system flag int Msg; bool Sys; CUuid Uuid; int Result = UnpackMessageID(&Msg, &Sys, &Uuid, &Unpacker, &Packer); if(Result == UNPACKMESSAGE_ERROR) { return; } if(g_Config.m_SvNetlimit && Msg != NETMSG_REQUEST_MAP_DATA) { int64 Now = time_get(); int64 Diff = Now - m_aClients[ClientID].m_TrafficSince; float Alpha = g_Config.m_SvNetlimitAlpha / 100.0; float Limit = (float)g_Config.m_SvNetlimit * 1024 / time_freq(); if (m_aClients[ClientID].m_Traffic > Limit) { m_NetServer.NetBan()->BanAddr(&pPacket->m_Address, 600, "Stressing network"); return; } if (Diff > 100) { m_aClients[ClientID].m_Traffic = (Alpha * ((float)pPacket->m_DataSize / Diff)) + (1.0 - Alpha) * m_aClients[ClientID].m_Traffic; m_aClients[ClientID].m_TrafficSince = Now; } } if(Result == UNPACKMESSAGE_ANSWER) { SendMsgEx(&Packer, MSGFLAG_VITAL, ClientID, true); } if(Sys) { // system message if(Msg == NETMSG_INFO) { if((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && m_aClients[ClientID].m_State == CClient::STATE_AUTH) { const char *pVersion = Unpacker.GetString(CUnpacker::SANITIZE_CC); if(!str_utf8_check(pVersion)) { return; } 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(!str_utf8_check(pPassword)) { return; } 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; SendRconType(ClientID, m_AuthManager.NumNonDefaultKeys() > 0); SendMap(ClientID); } } else if(Msg == NETMSG_REQUEST_MAP_DATA) { if((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) == 0 || m_aClients[ClientID].m_State < CClient::STATE_CONNECTING) return; int Chunk = Unpacker.GetInt(); if(Chunk != m_aClients[ClientID].m_NextMapChunk || !g_Config.m_SvFastDownload) { SendMapData(ClientID, Chunk); return; } if(Chunk == 0) { for(int i = 0; i < g_Config.m_SvMapWindow; i++) { SendMapData(ClientID, i); } } SendMapData(ClientID, g_Config.m_SvMapWindow + m_aClients[ClientID].m_NextMapChunk); m_aClients[ClientID].m_NextMapChunk++; } else if(Msg == NETMSG_READY) { if((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && 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=%d addr=%s secure=%s", ClientID, aAddrStr, m_NetServer.HasSecurityToken(ClientID)?"yes":"no"); 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((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && 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=%d 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(!str_utf8_check(pCmd)) { return; } if(Unpacker.Error() == 0 && !str_comp(pCmd, "crashmeplx")) { int version = GameServer()->GetClientVersion(ClientID); if (GameServer()->PlayerExists(ClientID) && version < VERSION_DDNET_OLD) GameServer()->SetClientVersion(ClientID, VERSION_DDNET_OLD); } else if((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && Unpacker.Error() == 0 && m_aClients[ClientID].m_Authed) { if (GameServer()->PlayerExists(ClientID)) { 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 : m_aClients[ClientID].m_Authed == AUTHED_HELPER ? IConsole::ACCESS_LEVEL_HELPER : 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 *pName = Unpacker.GetString(CUnpacker::SANITIZE_CC); // login name, now used const char *pPw = Unpacker.GetString(CUnpacker::SANITIZE_CC); if(!str_utf8_check(pPw) || !str_utf8_check(pName)) { return; } if((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && Unpacker.Error() == 0) { int AuthLevel = -1; int KeySlot = -1; if(!pName[0]) { if(m_AuthManager.CheckKey((KeySlot = m_AuthManager.DefaultKey(AUTHED_ADMIN)), pPw)) AuthLevel = AUTHED_ADMIN; else if(m_AuthManager.CheckKey((KeySlot = m_AuthManager.DefaultKey(AUTHED_MOD)), pPw)) AuthLevel = AUTHED_MOD; else if(m_AuthManager.CheckKey((KeySlot = m_AuthManager.DefaultKey(AUTHED_HELPER)), pPw)) AuthLevel = AUTHED_HELPER; } else { KeySlot = m_AuthManager.FindKey(pName); if(m_AuthManager.CheckKey(KeySlot, pPw)) AuthLevel = m_AuthManager.KeyLevel(KeySlot); } if(AuthLevel != -1) { if(m_aClients[ClientID].m_Authed != AuthLevel) { 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 = AuthLevel; // Keeping m_Authed around is unwise... m_aClients[ClientID].m_AuthKey = KeySlot; int SendRconCmds = Unpacker.GetInt(); if(Unpacker.Error() == 0 && SendRconCmds) // AUTHED_ADMIN - AuthLevel gets the proper IConsole::ACCESS_LEVEL_ m_aClients[ClientID].m_pRconCmdToSend = Console()->FirstCommandInfo(AUTHED_ADMIN - AuthLevel, CFGFLAG_SERVER); char aBuf[256]; const char *pIdent = m_AuthManager.KeyIdent(KeySlot); switch (AuthLevel) { case AUTHED_ADMIN: { SendRconLine(ClientID, "Admin authentication successful. Full remote console access granted."); str_format(aBuf, sizeof(aBuf), "ClientID=%d authed with key=%s (admin)", ClientID, pIdent); break; } case AUTHED_MOD: { SendRconLine(ClientID, "Moderator authentication successful. Limited remote console access granted."); str_format(aBuf, sizeof(aBuf), "ClientID=%d authed with key=%s (moderator)", ClientID, pIdent); break; } case AUTHED_HELPER: { SendRconLine(ClientID, "Helper authentication successful. Limited remote console access granted."); str_format(aBuf, sizeof(aBuf), "ClientID=%d authed with key=%s (helper)", ClientID, pIdent); break; } } Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf); // DDRace GameServer()->OnSetAuthed(ClientID, AuthLevel); } } 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((pPacket->m_Flags&NET_CHUNKFLAG_VITAL) != 0 && m_aClients[ClientID].m_State >= CClient::STATE_READY) GameServer()->OnMessage(Msg, &Unpacker, ClientID); } } void CServer::SendServerInfoConnless(const NETADDR *pAddr, int Token, int Type) { const int MaxRequests = g_Config.m_SvServerInfoPerSecond; int64 Now = Tick(); if(Now <= m_ServerInfoFirstRequest + TickSpeed()) { m_ServerInfoNumRequests++; } else { m_ServerInfoHighLoad = m_ServerInfoNumRequests > MaxRequests; m_ServerInfoNumRequests = 1; m_ServerInfoFirstRequest = Now; } bool SendClients = m_ServerInfoNumRequests <= MaxRequests && !m_ServerInfoHighLoad; SendServerInfo(pAddr, Token, Type, SendClients); } void CServer::SendServerInfo(const NETADDR *pAddr, int Token, int Type, bool SendClients) { // One chance to improve the protocol! 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(); #define ADD_RAW(p, x) (p).AddRaw(x, sizeof(x)) #define ADD_INT(p, x) do { str_format(aBuf, sizeof(aBuf), "%d", x); (p).AddString(aBuf, 0); } while(0) switch(Type) { case SERVERINFO_EXTENDED: ADD_RAW(p, SERVERBROWSE_INFO_EXTENDED); break; case SERVERINFO_64_LEGACY: ADD_RAW(p, SERVERBROWSE_INFO_64_LEGACY); break; case SERVERINFO_VANILLA: ADD_RAW(p, SERVERBROWSE_INFO); break; case SERVERINFO_INGAME: ADD_RAW(p, SERVERBROWSE_INFO); break; default: dbg_assert(false, "unknown serverinfo type"); } ADD_INT(p, Token); p.AddString(GameServer()->Version(), 32); if(Type != SERVERINFO_VANILLA) { p.AddString(g_Config.m_SvName, 256); } else { if(m_NetServer.MaxClients() <= VANILLA_MAX_CLIENTS) { p.AddString(g_Config.m_SvName, 64); } else { str_format(aBuf, sizeof(aBuf), "%s [%d/%d]", g_Config.m_SvName, ClientCount, m_NetServer.MaxClients()); p.AddString(aBuf, 64); } } p.AddString(GetMapName(), 32); if(Type == SERVERINFO_EXTENDED) { ADD_INT(p, m_CurrentMapCrc); ADD_INT(p, m_CurrentMapSize); } // gametype p.AddString(GameServer()->GameType(), 16); // flags ADD_INT(p, g_Config.m_Password[0] ? SERVER_FLAG_PASSWORD : 0); int MaxClients = m_NetServer.MaxClients(); if(Type == SERVERINFO_VANILLA || Type == SERVERINFO_INGAME) { if(ClientCount >= VANILLA_MAX_CLIENTS) { if(ClientCount < MaxClients) ClientCount = VANILLA_MAX_CLIENTS - 1; else ClientCount = VANILLA_MAX_CLIENTS; } if(MaxClients > VANILLA_MAX_CLIENTS) MaxClients = VANILLA_MAX_CLIENTS; if(PlayerCount > ClientCount) PlayerCount = ClientCount; } ADD_INT(p, PlayerCount); // num players ADD_INT(p, MaxClients-g_Config.m_SvSpectatorSlots); // max players ADD_INT(p, ClientCount); // num clients ADD_INT(p, MaxClients); // max clients if(Type == SERVERINFO_EXTENDED) p.AddString("", 0); // extra info, reserved const void *pPrefix = p.Data(); int PrefixSize = p.Size(); CPacker pp; CNetChunk Packet; int PacketsSent = 0; int PlayersSent = 0; Packet.m_ClientID = -1; Packet.m_Address = *pAddr; Packet.m_Flags = NETSENDFLAG_CONNLESS; #define SEND(size) \ do \ { \ Packet.m_pData = pp.Data(); \ Packet.m_DataSize = size; \ m_NetServer.Send(&Packet); \ PacketsSent++; \ } while(0) #define RESET() \ do \ { \ pp.Reset(); \ pp.AddRaw(pPrefix, PrefixSize); \ } while(0) RESET(); if(Type == SERVERINFO_64_LEGACY) pp.AddInt(PlayersSent); // offset if(!SendClients) { SEND(pp.Size()); return; } if(Type == SERVERINFO_EXTENDED) { pPrefix = SERVERBROWSE_INFO_EXTENDED_MORE; PrefixSize = sizeof(SERVERBROWSE_INFO_EXTENDED_MORE); } int Remaining; switch(Type) { case SERVERINFO_EXTENDED: Remaining = -1; break; case SERVERINFO_64_LEGACY: Remaining = 24; break; case SERVERINFO_VANILLA: Remaining = VANILLA_MAX_CLIENTS; break; case SERVERINFO_INGAME: Remaining = VANILLA_MAX_CLIENTS; break; default: dbg_assert(0, "caught earlier, unreachable"); return; } // Use the following strategy for sending: // For vanilla, send the first 16 players. // For legacy 64p, send 24 players per packet. // For extended, send as much players as possible. for(int i = 0; i < MAX_CLIENTS; i++) { if(m_aClients[i].m_State != CClient::STATE_EMPTY) { if(Remaining == 0) { if(Type == SERVERINFO_VANILLA || Type == SERVERINFO_INGAME) break; // Otherwise we're SERVERINFO_64_LEGACY. SEND(pp.Size()); RESET(); pp.AddInt(PlayersSent); // offset Remaining = 24; } if(Remaining > 0) { Remaining--; } int PreviousSize = pp.Size(); pp.AddString(ClientName(i), MAX_NAME_LENGTH); // client name pp.AddString(ClientClan(i), MAX_CLAN_LENGTH); // client clan ADD_INT(pp, m_aClients[i].m_Country); // client country ADD_INT(pp, m_aClients[i].m_Score); // client score ADD_INT(pp, GameServer()->IsClientPlayer(i) ? 1 : 0); // is player? if(Type == SERVERINFO_EXTENDED) pp.AddString("", 0); // extra info, reserved if(Type == SERVERINFO_EXTENDED) { if(pp.Size() >= NET_MAX_PAYLOAD) { // Retry current player. i--; SEND(PreviousSize); RESET(); ADD_INT(pp, Token); ADD_INT(pp, PacketsSent); pp.AddString("", 0); // extra info, reserved continue; } } PlayersSent++; } } SEND(pp.Size()); #undef SEND #undef RESET #undef ADD_RAW #undef ADD_INT } 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, SERVERINFO_INGAME, false); } } } 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)) { int ExtraToken = 0; int Type = -1; if(Packet.m_DataSize >= (int)sizeof(SERVERBROWSE_GETINFO)+1 && mem_comp(Packet.m_pData, SERVERBROWSE_GETINFO, sizeof(SERVERBROWSE_GETINFO)) == 0) { if(Packet.m_Flags&NETSENDFLAG_EXTENDED) { Type = SERVERINFO_EXTENDED; ExtraToken = (Packet.m_aExtraData[0] << 8) | Packet.m_aExtraData[1]; } else Type = SERVERINFO_VANILLA; } else if(Packet.m_DataSize >= (int)sizeof(SERVERBROWSE_GETINFO_64_LEGACY)+1 && mem_comp(Packet.m_pData, SERVERBROWSE_GETINFO_64_LEGACY, sizeof(SERVERBROWSE_GETINFO_64_LEGACY)) == 0) { Type = SERVERINFO_64_LEGACY; } if(Type != -1) { int Token = ((unsigned char *)Packet.m_pData)[sizeof(SERVERBROWSE_GETINFO)]; Token |= ExtraToken << 8; SendServerInfoConnless(&Packet.m_Address, Token, Type); } } } else ProcessClientPacket(&Packet); } m_ServerBan.Update(); m_Econ.Update(); #if defined(CONF_FAMILY_UNIX) m_Fifo.Update(); #endif } 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) { char aBuf[512]; str_format(aBuf, sizeof(aBuf), "maps/%s.map", pMapName); GameServer()->OnMapChange(aBuf, sizeof(aBuf)); if(!m_pMap->Load(aBuf)) return 0; // stop recording when we change map for(int i = 0; i < MAX_CLIENTS+1; i++) { m_aDemoRecorder[i].Stop(); // remove tmp demos if(i < MAX_CLIENTS) { char aPath[256]; str_format(aPath, sizeof(aPath), "demos/%s_%d_%d_tmp.demo", m_aCurrentMap, g_Config.m_SvPort, i); Storage()->RemoveFile(aPath, IStorage::TYPE_SAVE); } } // 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)); // load complete map into memory for download { IOHANDLE File = Storage()->OpenFile(aBuf, IOFLAG_READ, IStorage::TYPE_ALL); m_CurrentMapSize = (unsigned 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; iRegisterPrintCallback(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.type = NETTYPE_ALL; 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, NewClientNoAuthCallback, ClientRejoinCallback, DelClientCallback, this); m_Econ.Init(Console(), &m_ServerBan); #if defined(CONF_FAMILY_UNIX) m_Fifo.Init(Console(), g_Config.m_SvInputFifo, CFGFLAG_SERVER); #endif 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); if(m_AuthManager.IsGenerated()) { dbg_msg("server", "+-------------------------+"); dbg_msg("server", "| rcon password: '%s' |", g_Config.m_SvRconPassword); dbg_msg("server", "+-------------------------+"); } // start game { bool NonActive = false; 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) { if(NonActive) PumpNetwork(); set_new_tick(); 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 ClientID = 0; ClientID < MAX_CLIENTS; ClientID++) { if(m_aClients[ClientID].m_State <= CClient::STATE_AUTH) continue; SendMap(ClientID); m_aClients[ClientID].Reset(); m_aClients[ClientID].m_State = CClient::STATE_CONNECTING; } m_GameStartTime = time_get(); m_CurrentGameTick = 0; m_ServerInfoFirstRequest = 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)); } } // handle dnsbl if (g_Config.m_SvDnsbl) { for (int ClientID = 0; ClientID < MAX_CLIENTS; ClientID++) { if (m_aClients[ClientID].m_State == CClient::STATE_EMPTY) continue; if (m_aClients[ClientID].m_DnsblState == CClient::DNSBL_STATE_NONE) { // initiate dnsbl lookup m_aClients[ClientID].m_DnsblState = CClient::DNSBL_STATE_PENDING; InitDnsbl(ClientID); } else if (m_aClients[ClientID].m_DnsblState == CClient::DNSBL_STATE_PENDING && m_aClients[ClientID].m_DnsblLookup.m_Job.Status() == CJob::STATE_DONE) { if (m_aClients[ClientID].m_DnsblLookup.m_Job.Result() != 0) { // entry not found -> whitelisted m_aClients[ClientID].m_DnsblState = CClient::DNSBL_STATE_WHITELISTED; } else { // entry found -> blacklisted m_aClients[ClientID].m_DnsblState = CClient::DNSBL_STATE_BLACKLISTED; // console output char aAddrStr[NETADDR_MAXSTRSIZE]; net_addr_str(m_NetServer.ClientAddr(ClientID), aAddrStr, sizeof(aAddrStr), true); char aBuf[256]; str_format(aBuf, sizeof(aBuf), "ClientID=%d addr=%s secure=%s blacklisted", ClientID, aAddrStr, m_NetServer.HasSecurityToken(ClientID)?"yes":"no"); Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "dnsbl", aBuf); } } if (m_aClients[ClientID].m_DnsblState == CClient::DNSBL_STATE_BLACKLISTED && g_Config.m_SvDnsblBan) m_NetServer.NetBan()->BanAddr(m_NetServer.ClientAddr(ClientID), 60*10, "Blacklisted by DNSBL"); } } 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_INGAME) continue; for(int i = 0; i < 200; i++) { if(m_aClients[c].m_aInputs[i].m_GameTick == Tick()) { 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()); if(!NonActive) PumpNetwork(); NonActive = true; for(int c = 0; c < MAX_CLIENTS; c++) if(m_aClients[c].m_State != CClient::STATE_EMPTY) NonActive = false; // wait for incoming data if (NonActive) { if(g_Config.m_SvReloadWhenEmpty == 1) { m_MapReload = true; g_Config.m_SvReloadWhenEmpty = 0; } else if(g_Config.m_SvReloadWhenEmpty == 2 && !m_ReloadedWhenEmpty) { m_MapReload = true; m_ReloadedWhenEmpty = true; } if(g_Config.m_SvShutdownWhenEmpty) m_RunServer = false; else net_socket_read_wait(m_NetServer.Socket(), 1000000); } else { m_ReloadedWhenEmpty = false; set_new_tick(); int64 t = time_get(); int x = (TickStartTime(m_CurrentGameTick+1) - t) * 1000000 / time_freq() + 1; if(x > 0) { net_socket_read_wait(m_NetServer.Socket(), x); } } } } // 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(); #if defined(CONF_FAMILY_UNIX) m_Fifo.Shutdown(); #endif GameServer()->OnShutdown(true); m_pMap->Unload(); if(m_pCurrentMapData) mem_free(m_pCurrentMapData); #if defined (CONF_SQL) for (int i = 0; i < MAX_SQLSERVERS; i++) { if (m_apSqlReadServers[i]) delete m_apSqlReadServers[i]; if (m_apSqlWriteServers[i]) delete m_apSqlWriteServers[i]; } #endif 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::ConRescue(CConsole::IResult *pResult, void *pUser) { char aBuf[128]; str_format(aBuf, sizeof(aBuf), "Value: %d", g_Config.m_SvRescue); ((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::StatusImpl(IConsole::IResult *pResult, void *pUser, bool DnsblBlacklistedOnly) { char aBuf[1024]; char aAddrStr[NETADDR_MAXSTRSIZE]; CServer *pThis = static_cast(pUser); bool CanSeeAddress = pThis->m_aClients[pResult->m_ClientID].m_Authed > CServer::AUTHED_MOD; for(int i = 0; i < MAX_CLIENTS; i++) { if( pThis->m_aClients[i].m_State != CClient::STATE_EMPTY && (!DnsblBlacklistedOnly || pThis->m_aClients[i].m_DnsblState == CClient::DNSBL_STATE_BLACKLISTED) ) { net_addr_str(pThis->m_NetServer.ClientAddr(i), aAddrStr, sizeof(aAddrStr), true); if(pThis->m_aClients[i].m_State == CClient::STATE_INGAME) { const char *pAuthStr = pThis->m_aClients[i].m_Authed == CServer::AUTHED_ADMIN ? "(Admin)" : pThis->m_aClients[i].m_Authed == CServer::AUTHED_MOD ? "(Mod)" : pThis->m_aClients[i].m_Authed == CServer::AUTHED_HELPER ? "(Helper)" : ""; char aAuthStr[128]; aAuthStr[0] = '\0'; if(pThis->m_aClients[i].m_AuthKey >= 0) str_format(aAuthStr, sizeof(aAuthStr), "key=%s %s", pThis->m_AuthManager.KeyIdent(pThis->m_aClients[i].m_AuthKey), pAuthStr); if(CanSeeAddress) str_format(aBuf, sizeof(aBuf), "id=%d addr=%s name='%s' score=%d client=%d secure=%s %s", i, aAddrStr, pThis->m_aClients[i].m_aName, pThis->m_aClients[i].m_Score, pThis->GameServer()->GetClientVersion(i), pThis->m_NetServer.HasSecurityToken(i) ? "yes" : "no", aAuthStr); else str_format(aBuf, sizeof(aBuf), "id=%d name='%s' score=%d client=%d secure=%s %s", i, pThis->m_aClients[i].m_aName, pThis->m_aClients[i].m_Score, pThis->GameServer()->GetClientVersion(i), pThis->m_NetServer.HasSecurityToken(i) ? "yes" : "no", aAuthStr); } else { if(CanSeeAddress) str_format(aBuf, sizeof(aBuf), "id=%d addr=%s connecting", i, aAddrStr); else str_format(aBuf, sizeof(aBuf), "id=%d connecting", i); } pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "Server", aBuf); } } } void CServer::ConStatus(IConsole::IResult *pResult, void *pUser) { StatusImpl(pResult, pUser, false); } void CServer::ConDnsblStatus(IConsole::IResult *pResult, void *pUser) { StatusImpl(pResult, pUser, true); } static int GetAuthLevel(const char *pLevel) { int Level = -1; if(!str_comp_nocase(pLevel, "admin")) Level = CServer::AUTHED_ADMIN; else if(!str_comp_nocase_num(pLevel, "mod", 3)) Level = CServer::AUTHED_MOD; else if(!str_comp_nocase(pLevel, "helper")) Level = CServer::AUTHED_HELPER; return Level; } void CServer::AuthRemoveKey(int KeySlot) { int NewKeySlot = KeySlot; int OldKeySlot = m_AuthManager.RemoveKey(KeySlot); LogoutKey(KeySlot, "key removal"); // Update indices. if(OldKeySlot != NewKeySlot) { for(int i = 0; i < MAX_CLIENTS; i++) if(m_aClients[i].m_AuthKey == OldKeySlot) m_aClients[i].m_AuthKey = NewKeySlot; } } void CServer::ConAuthAdd(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; const char *pIdent = pResult->GetString(0); const char *pLevel = pResult->GetString(1); const char *pPw = pResult->GetString(2); int Level = GetAuthLevel(pLevel); if(Level == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "level can be one of {\"admin\", \"mod(erator)\", \"helper\"}"); return; } bool NeedUpdate = !pManager->NumNonDefaultKeys(); if(pManager->AddKey(pIdent, pPw, Level) < 0) pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "ident already exists"); else { if(NeedUpdate) pThis->SendRconType(-1, true); pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "key added"); } } void CServer::ConAuthAddHashed(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; const char *pIdent = pResult->GetString(0); const char *pLevel = pResult->GetString(1); const char *pPw = pResult->GetString(2); const char *pSalt = pResult->GetString(3); int Level = GetAuthLevel(pLevel); if(Level == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "level can be one of {\"admin\", \"mod(erator)\", \"helper\"}"); return; } unsigned char aHash[MD5_BYTES]; unsigned char aSalt[SALT_BYTES]; if(str_hex_decode(aHash, sizeof(aHash), pPw)) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "Malformed password hash"); return; } if(str_hex_decode(aSalt, sizeof(aSalt), pSalt)) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "Malformed salt hash"); return; } bool NeedUpdate = !pManager->NumNonDefaultKeys(); if(pManager->AddKeyHash(pIdent, aHash, aSalt, Level) < 0) pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "ident already exists"); else { if(NeedUpdate) pThis->SendRconType(-1, true); pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "key added"); } } void CServer::ConAuthUpdate(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; const char *pIdent = pResult->GetString(0); const char *pLevel = pResult->GetString(1); const char *pPw = pResult->GetString(2); int KeySlot = pManager->FindKey(pIdent); if(KeySlot == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "ident couldn't be found"); return; } int Level = GetAuthLevel(pLevel); if(Level == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "level can be one of {\"admin\", \"mod(erator)\", \"helper\"}"); return; } pManager->UpdateKey(KeySlot, pPw, Level); pThis->LogoutKey(KeySlot, "key update"); pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "key updated"); } void CServer::ConAuthUpdateHashed(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; const char *pIdent = pResult->GetString(0); const char *pLevel = pResult->GetString(1); const char *pPw = pResult->GetString(2); const char *pSalt = pResult->GetString(3); int KeySlot = pManager->FindKey(pIdent); if(KeySlot == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "ident couldn't be found"); return; } int Level = GetAuthLevel(pLevel); if(Level == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "level can be one of {\"admin\", \"mod(erator)\", \"helper\"}"); return; } unsigned char aHash[MD5_BYTES]; unsigned char aSalt[SALT_BYTES]; if(str_hex_decode(aHash, sizeof(aHash), pPw)) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "Malformed password hash"); return; } if(str_hex_decode(aSalt, sizeof(aSalt), pSalt)) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "Malformed salt hash"); return; } pManager->UpdateKeyHash(KeySlot, aHash, aSalt, Level); pThis->LogoutKey(KeySlot, "key update"); pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "key updated"); } void CServer::ConAuthRemove(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; const char *pIdent = pResult->GetString(0); int KeySlot = pManager->FindKey(pIdent); if(KeySlot == -1) { pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "ident couldn't be found"); return; } pThis->AuthRemoveKey(KeySlot); if(!pManager->NumNonDefaultKeys()) pThis->SendRconType(-1, false); pThis->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", "key removed, all users logged out"); } static void ListKeysCallback(const char *pIdent, int Level, void *pUser) { static const char LSTRING[][10] = {"helper", "moderator", "admin"}; char aBuf[256]; str_format(aBuf, sizeof(aBuf), "%s %s", pIdent, LSTRING[Level - 1]); ((CServer *)pUser)->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "auth", aBuf); } void CServer::ConAuthList(IConsole::IResult *pResult, void *pUser) { CServer *pThis = (CServer *)pUser; CAuthManager *pManager = &pThis->m_AuthManager; pManager->ListKeys(ListKeysCallback, pThis); } void CServer::ConShutdown(IConsole::IResult *pResult, void *pUser) { ((CServer *)pUser)->m_RunServer = 0; } void CServer::DemoRecorder_HandleAutoStart() { if(g_Config.m_SvAutoDemoRecord) { m_aDemoRecorder[MAX_CLIENTS].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_aDemoRecorder[MAX_CLIENTS].Start(Storage(), m_pConsole, aFilename, GameServer()->NetVersion(), m_aCurrentMap, m_CurrentMapCrc, "server", m_CurrentMapSize, m_pCurrentMapData); 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_aDemoRecorder[MAX_CLIENTS].IsRecording(); } void CServer::SaveDemo(int ClientID, float Time) { if(IsRecording(ClientID)) { m_aDemoRecorder[ClientID].Stop(); // rename the demo char aOldFilename[256]; char aNewFilename[256]; str_format(aOldFilename, sizeof(aOldFilename), "demos/%s_%d_%d_tmp.demo", m_aCurrentMap, g_Config.m_SvPort, ClientID); str_format(aNewFilename, sizeof(aNewFilename), "demos/%s_%s_%5.2f.demo", m_aCurrentMap, m_aClients[ClientID].m_aName, Time); Storage()->RenameFile(aOldFilename, aNewFilename, IStorage::TYPE_SAVE); } } void CServer::StartRecord(int ClientID) { if(g_Config.m_SvPlayerDemoRecord) { char aFilename[128]; str_format(aFilename, sizeof(aFilename), "demos/%s_%d_%d_tmp.demo", m_aCurrentMap, g_Config.m_SvPort, ClientID); m_aDemoRecorder[ClientID].Start(Storage(), Console(), aFilename, GameServer()->NetVersion(), m_aCurrentMap, m_CurrentMapCrc, "server", m_CurrentMapSize, m_pCurrentMapData); } } void CServer::StopRecord(int ClientID) { if(IsRecording(ClientID)) { m_aDemoRecorder[ClientID].Stop(); char aFilename[128]; str_format(aFilename, sizeof(aFilename), "demos/%s_%d_%d_tmp.demo", m_aCurrentMap, g_Config.m_SvPort, ClientID); Storage()->RemoveFile(aFilename, IStorage::TYPE_SAVE); } } bool CServer::IsRecording(int ClientID) { return m_aDemoRecorder[ClientID].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_aDemoRecorder[MAX_CLIENTS].Start(pServer->Storage(), pServer->Console(), aFilename, pServer->GameServer()->NetVersion(), pServer->m_aCurrentMap, pServer->m_CurrentMapCrc, "server", pServer->m_CurrentMapSize, pServer->m_pCurrentMapData); } void CServer::ConStopRecord(IConsole::IResult *pResult, void *pUser) { ((CServer *)pUser)->m_aDemoRecorder[MAX_CLIENTS].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) { pServer->LogoutClient(pServer->m_RconClientID, ""); } } #if defined (CONF_SQL) void CServer::ConAddSqlServer(IConsole::IResult *pResult, void *pUserData) { CServer *pSelf = (CServer *)pUserData; if (pResult->NumArguments() != 7 && pResult->NumArguments() != 8) { pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "7 or 8 arguments are required"); return; } bool ReadOnly; if (str_comp_nocase(pResult->GetString(0), "w") == 0) ReadOnly = false; else if (str_comp_nocase(pResult->GetString(0), "r") == 0) ReadOnly = true; else { pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "choose either 'r' for SqlReadServer or 'w' for SqlWriteServer"); return; } bool SetUpDb = pResult->NumArguments() == 8 ? pResult->GetInteger(7) : false; CSqlServer** apSqlServers = ReadOnly ? pSelf->m_apSqlReadServers : pSelf->m_apSqlWriteServers; for (int i = 0; i < MAX_SQLSERVERS; i++) { if (!apSqlServers[i]) { apSqlServers[i] = new CSqlServer(pResult->GetString(1), pResult->GetString(2), pResult->GetString(3), pResult->GetString(4), pResult->GetString(5), pResult->GetInteger(6), ReadOnly, SetUpDb); if(SetUpDb) { void *TablesThread = thread_init(CreateTablesThread, apSqlServers[i]); thread_detach(TablesThread); } char aBuf[512]; str_format(aBuf, sizeof(aBuf), "Added new Sql%sServer: %d: DB: '%s' Prefix: '%s' User: '%s' IP: '%s' Port: %d", ReadOnly ? "Read" : "Write", i, apSqlServers[i]->GetDatabase(), apSqlServers[i]->GetPrefix(), apSqlServers[i]->GetUser(), apSqlServers[i]->GetIP(), apSqlServers[i]->GetPort()); pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf); return; } } pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "failed to add new sqlserver: limit of sqlservers reached"); } void CServer::ConDumpSqlServers(IConsole::IResult *pResult, void *pUserData) { CServer *pSelf = (CServer *)pUserData; bool ReadOnly; if (str_comp_nocase(pResult->GetString(0), "w") == 0) ReadOnly = false; else if (str_comp_nocase(pResult->GetString(0), "r") == 0) ReadOnly = true; else { pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "choose either 'r' for SqlReadServer or 'w' for SqlWriteServer"); return; } CSqlServer** apSqlServers = ReadOnly ? pSelf->m_apSqlReadServers : pSelf->m_apSqlWriteServers; for (int i = 0; i < MAX_SQLSERVERS; i++) if (apSqlServers[i]) { char aBuf[512]; str_format(aBuf, sizeof(aBuf), "SQL-%s %d: DB: '%s' Prefix: '%s' User: '%s' Pass: '%s' IP: '%s' Port: %d", ReadOnly ? "Read" : "Write", i, apSqlServers[i]->GetDatabase(), apSqlServers[i]->GetPrefix(), apSqlServers[i]->GetUser(), apSqlServers[i]->GetPass(), apSqlServers[i]->GetIP(), apSqlServers[i]->GetPort()); pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf); } } void CServer::CreateTablesThread(void *pData) { ((CSqlServer *)pData)->CreateTables(); } #endif 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::ConchainCommandAccessUpdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData) { if(pResult->NumArguments() == 2) { CServer *pThis = static_cast(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 || (pInfo->GetAccessLevel() > AUTHED_ADMIN - pThis->m_aClients[i].m_Authed && AUTHED_ADMIN - pThis->m_aClients[i].m_Authed < OldAccessLevel) || (pInfo->GetAccessLevel() < AUTHED_ADMIN - pThis->m_aClients[i].m_Authed && AUTHED_ADMIN - pThis->m_aClients[i].m_Authed > OldAccessLevel) || (pThis->m_aClients[i].m_pRconCmdToSend && str_comp(pResult->GetString(0), pThis->m_aClients[i].m_pRconCmdToSend->m_pName) >= 0)) continue; if(OldAccessLevel < pInfo->GetAccessLevel()) 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(pUserData); pThis->Console()->SetPrintOutputLevel(pThis->m_PrintCBIndex, pResult->GetInteger(0)); } } void CServer::LogoutClient(int ClientID, const char *pReason) { CMsgPacker Msg(NETMSG_RCON_AUTH_STATUS); Msg.AddInt(0); //authed Msg.AddInt(0); //cmdlist SendMsgEx(&Msg, MSGFLAG_VITAL, ClientID, true); m_aClients[ClientID].m_AuthTries = 0; m_aClients[ClientID].m_pRconCmdToSend = 0; char aBuf[64]; if(*pReason) { str_format(aBuf, sizeof(aBuf), "Logged out by %s.", pReason); SendRconLine(ClientID, aBuf); str_format(aBuf, sizeof(aBuf), "ClientID=%d with key=%s logged out by %s", ClientID, m_AuthManager.KeyIdent(m_aClients[ClientID].m_AuthKey), pReason); } else { SendRconLine(ClientID, "Logout successful."); str_format(aBuf, sizeof(aBuf), "ClientID=%d with key=%s logged out", ClientID, m_AuthManager.KeyIdent(m_aClients[ClientID].m_AuthKey)); } m_aClients[ClientID].m_Authed = AUTHED_NO; m_aClients[ClientID].m_AuthKey = -1; Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf); } void CServer::LogoutKey(int Key, const char *pReason) { for(int i = 0; i < MAX_CLIENTS; i++) if(m_aClients[i].m_AuthKey == Key) LogoutClient(i, pReason); } void CServer::ConchainRconPasswordChangeGeneric(int Level, IConsole::IResult *pResult) { if(pResult->NumArguments() == 1) { int KeySlot = m_AuthManager.DefaultKey(Level); if(KeySlot == -1 && pResult->GetString(0)[0]) { m_AuthManager.AddDefaultKey(Level, pResult->GetString(0)); } else if(KeySlot >= 0) { if(!pResult->GetString(0)[0]) { AuthRemoveKey(KeySlot); // Already logs users out. } else { m_AuthManager.UpdateKey(KeySlot, pResult->GetString(0), Level); LogoutKey(KeySlot, "key update"); } } } } void CServer::ConchainRconPasswordChange(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData) { pfnCallback(pResult, pCallbackUserData); ((CServer *)pUserData)->ConchainRconPasswordChangeGeneric(AUTHED_ADMIN, pResult); } void CServer::ConchainRconModPasswordChange(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData) { pfnCallback(pResult, pCallbackUserData); ((CServer *)pUserData)->ConchainRconPasswordChangeGeneric(AUTHED_MOD, pResult); } void CServer::ConchainRconHelperPasswordChange(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData) { pfnCallback(pResult, pCallbackUserData); ((CServer *)pUserData)->ConchainRconPasswordChangeGeneric(AUTHED_HELPER, pResult); } void CServer::RegisterCommands() { m_pConsole = Kernel()->RequestInterface(); m_pGameServer = Kernel()->RequestInterface(); m_pMap = Kernel()->RequestInterface(); m_pStorage = Kernel()->RequestInterface(); // register console commands Console()->Register("kick", "i[id] ?r[reason]", 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[file]", 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"); #if defined (CONF_SQL) Console()->Register("add_sqlserver", "s['r'|'w'] s[Database] s[Prefix] s[User] s[Password] s[IP] i[Port] ?i[SetUpDatabase ?]", CFGFLAG_SERVER, ConAddSqlServer, this, "add a sqlserver"); Console()->Register("dump_sqlservers", "s['r'|'w']", CFGFLAG_SERVER, ConDumpSqlServers, this, "dumps all sqlservers readservers = r, writeservers = w"); #endif Console()->Register("dnsbl_status", "", CFGFLAG_SERVER, ConDnsblStatus, this, "List blacklisted players"); Console()->Register("auth_add", "s[ident] s[level] s[pw]", CFGFLAG_SERVER, ConAuthAdd, this, "Add a rcon key"); Console()->Register("auth_add_p", "s[ident] s[level] s[hash] s[salt]", CFGFLAG_SERVER, ConAuthAddHashed, this, "Add a prehashed rcon key"); Console()->Register("auth_change", "s[ident] s[level] s[pw]", CFGFLAG_SERVER, ConAuthUpdate, this, "Update a rcon key"); Console()->Register("auth_change_p", "s[ident] s[level] s[hash] s[salt]", CFGFLAG_SERVER, ConAuthUpdateHashed, this, "Update a rcon key with prehashed data"); Console()->Register("auth_remove", "s[ident]", CFGFLAG_SERVER, ConAuthRemove, this, "Remove a rcon key"); Console()->Register("auth_list", "", CFGFLAG_SERVER, ConAuthList, this, "List all rcon keys"); Console()->Chain("sv_name", ConchainSpecialInfoupdate, this); Console()->Chain("password", ConchainSpecialInfoupdate, this); Console()->Chain("sv_max_clients_per_ip", ConchainMaxclientsperipUpdate, this); Console()->Chain("access_level", ConchainCommandAccessUpdate, this); Console()->Chain("console_output_level", ConchainConsoleOutputLevelUpdate, this); Console()->Chain("sv_rcon_password", ConchainRconPasswordChange, this); Console()->Chain("sv_rcon_mod_password", ConchainRconModPasswordChange, this); Console()->Chain("sv_rcon_helper_password", ConchainRconHelperPasswordChange, this); // register console commands in sub parts m_ServerBan.InitServerBan(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) { if(!(Type >= 0 && Type <= 0xffff)) { g_UuidManager.GetUuid(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 { bool Silent = false; for(int i = 1; i < argc; i++) // ignore_convention { if(str_comp("-s", argv[i]) == 0 || str_comp("--silent", argv[i]) == 0) // ignore_convention { Silent = true; #if defined(CONF_FAMILY_WINDOWS) ShowWindow(GetConsoleWindow(), SW_HIDE); #endif break; } } #if !defined(CONF_PLATFORM_MACOSX) && !defined(FUZZING) dbg_enable_threaded(); #endif if(secure_random_init() != 0) { dbg_msg("secure", "could not initialize secure RNG"); return -1; } CServer *pServer = CreateServer(); IKernel *pKernel = IKernel::Create(); // create the components IEngine *pEngine = CreateEngine("DDNet", Silent); 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); RegisterFail = RegisterFail || !pKernel->RegisterInterface(pEngine); RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast(pEngineMap)); // register as both RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast(pEngineMap), false); 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(pEngineMasterServer)); // register as both RegisterFail = RegisterFail || !pKernel->RegisterInterface(static_cast(pEngineMasterServer), false); if(RegisterFail) { delete pKernel; return -1; } } pEngine->Init(); pConfig->Init(); pEngineMasterServer->Init(); pEngineMasterServer->Load(); // register all console commands pServer->RegisterCommands(); // execute autoexec file IOHANDLE File = pStorage->OpenFile(AUTOEXEC_SERVER_FILE, IOFLAG_READ, IStorage::TYPE_ALL); if(File) { io_close(File); pConsole->ExecuteFile(AUTOEXEC_SERVER_FILE); } else // fallback { pConsole->ExecuteFile(AUTOEXEC_FILE); } // 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, CServer::ConTestingCommands, pConsole, "Turns testing commands aka cheats on/off"); pConsole->Register("sv_rescue", "", CFGFLAG_SERVER, CServer::ConRescue, pConsole, "Allow /rescue command so players can teleport themselves out of freeze"); pEngine->InitLogfile(); // run the server dbg_msg("server", "starting..."); pServer->Run(); // free delete pKernel; 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); } } const char *CServer::GetAnnouncementLine(char const *pFileName) { IOHANDLE File = m_pStorage->OpenFile(pFileName, IOFLAG_READ, IStorage::TYPE_ALL); if(!File) return 0; std::vector 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; } io_close(File); return v[m_AnnouncementLastLine]; } int* CServer::GetIdMap(int ClientID) { return (int*)(IdMap + VANILLA_MAX_CLIENTS * ClientID); } bool CServer::SetTimedOut(int ClientID, int OrigID) { if (!m_NetServer.SetTimedOut(ClientID, OrigID)) { return false; } DelClientCallback(OrigID, "Timeout Protection used", this); m_aClients[ClientID].m_Authed = IServer::AUTHED_NO; return true; }