BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/engine/sv_remoteaccess.cpp

934 lines
27 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Handles all the functions for implementing remote access to the engine
//
//===========================================================================//
#include "server_pch.h"
#include "iclient.h"
#include "net.h"
#include "utlbuffer.h"
#include "utllinkedlist.h"
#include "igameserverdata.h"
#include "sv_remoteaccess.h"
#include "sv_rcon.h"
#include "sv_filter.h"
#include "sys.h"
#include "vprof_engine.h"
#include "PlayerState.h"
#include "sv_log.h"
#ifndef SWDS
#include "zip/XZip.h"
#endif
#include "cl_main.h"
extern IServerGameDLL *serverGameDLL;
CServerRemoteAccess g_ServerRemoteAccess;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerRemoteAccess, IGameServerData, GAMESERVERDATA_INTERFACE_VERSION, g_ServerRemoteAccess);
ConVar sv_rcon_log( "sv_rcon_log", "1", 0, "Enable/disable rcon logging." );
//-----------------------------------------------------------------------------
// Host_Stats_f - prints out interesting stats about the server...
//-----------------------------------------------------------------------------
void Host_Stats_f (void)
{
char stats[512];
g_ServerRemoteAccess.GetStatsString(stats, sizeof(stats));
ConMsg("CPU In_(KB/s) Out_(KB/s) Uptime Map_changes FPS Players Connects\n%s\n", stats);
}
static ConCommand stats("stats", Host_Stats_f, "Prints server performance variables" );
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CServerRemoteAccess::CServerRemoteAccess()
{
m_iBytesSent = 0;
m_iBytesReceived = 0;
m_NextListenerID = 0;
m_AdminUIID = INVALID_LISTENER_ID;
m_nScreenshotListener = -1;
}
//-----------------------------------------------------------------------------
// Purpose: unique id to associate data transfers with sessions
//-----------------------------------------------------------------------------
ra_listener_id CServerRemoteAccess::GetNextListenerID( bool authConnection, const netadr_t *adr )
{
int i = m_ListenerIDs.AddToTail();
m_ListenerIDs[i].listenerID = i;
m_ListenerIDs[i].authenticated = !authConnection;
m_ListenerIDs[i].m_bHasAddress = ( adr != NULL );
if ( adr )
{
m_ListenerIDs[i].adr = *adr;
}
return i;
}
bool GetStringHelper( CUtlBuffer & cmd, char *outBuf, int bufSize )
{
outBuf[0] = 0;
cmd.GetStringManualCharCount( outBuf, bufSize );
if ( !cmd.IsValid() )
{
cmd.Purge();
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: handles a request
//-----------------------------------------------------------------------------
void CServerRemoteAccess::WriteDataRequest( CRConServer *pNetworkListener, ra_listener_id listener, const void *buffer, int bufferSize)
{
m_iBytesReceived += bufferSize;
// ConMsg("RemoteAccess: bytes received: %d\n", m_iBytesReceived);
if ( bufferSize < 2*sizeof(int) ) // check that the buffer contains at least the id and type
{
return;
}
CUtlBuffer cmd(buffer, bufferSize, CUtlBuffer::READ_ONLY);
bool invalidRequest = false;
while ( invalidRequest == false && (int)cmd.TellGet() < (int)(cmd.Size() - 2 * sizeof(int) ) ) // while there is commands to read
{
// parse out the buffer
int requestID = cmd.GetInt();
pNetworkListener->SetRequestID( listener, requestID ); // tell the rcon server the ID so it can reflect it when the console redirect flushes
int requestType = cmd.GetInt();
switch (requestType)
{
case SERVERDATA_REQUESTVALUE:
{
if ( IsAuthenticated(listener) )
{
char variable[256];
if ( !GetStringHelper( cmd, variable, sizeof(variable) ) )
{
invalidRequest = true;
break;
}
RequestValue( listener, requestID, variable);
if ( !GetStringHelper( cmd, variable, sizeof(variable) ) )
{
invalidRequest = true;
break;
}
}
else
{
char variable[256];
if ( !GetStringHelper( cmd, variable, sizeof(variable) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, variable, sizeof(variable) ) )
{
invalidRequest = true;
break;
}
}
}
break;
case SERVERDATA_SETVALUE:
{
if ( IsAuthenticated(listener) )
{
char variable[256];
char value[256];
if ( !GetStringHelper( cmd, variable, sizeof(variable) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, value, sizeof(value) ) )
{
invalidRequest = true;
break;
}
SetValue(variable, value);
}
else
{
char command[512];
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
}
}
break;
case SERVERDATA_EXECCOMMAND:
{
if ( IsAuthenticated(listener) )
{
char command[512];
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
ExecCommand(command);
if ( listener != m_AdminUIID )
{
LogCommand( listener, va( "command \"%s\"", command) );
}
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
}
else
{
char command[512];
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, command, sizeof(command) ) )
{
invalidRequest = true;
break;
}
LogCommand( listener, "Bad Password" );
}
}
break;
case SERVERDATA_AUTH:
{
char password[512];
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
CheckPassword( pNetworkListener, listener, requestID, password );
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
if ( m_ListenerIDs[ listener ].authenticated )
{
// if the second string has a non-zero value, it is a userid.
int userID = atoi( password );
const ConCommandBase *var = g_pCVar->GetCommands();
while ( var )
{
if ( var->IsCommand() )
{
if ( Q_stricmp( var->GetName(), "mp_disable_autokick" ) == 0 )
{
Cbuf_AddText( va( "mp_disable_autokick %d\n", userID ) );
Cbuf_Execute();
break;
}
}
var = var->GetNext();
}
}
}
break;
case SERVERDATA_TAKE_SCREENSHOT:
#ifndef SWDS
m_nScreenshotListener = listener;
CL_TakeJpeg( );
#endif
break;
case SERVERDATA_SEND_CONSOLE_LOG:
{
#ifndef SWDS
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( GetConsoleLogFileData( buf ) )
{
HZIP hZip = CreateZipZ( 0, 1024 * 1024, ZIP_MEMORY );
void *pMem;
unsigned long nLen;
ZipAdd( hZip, "console.log", buf.Base(), buf.TellMaxPut(), ZIP_MEMORY );
ZipGetMemory( hZip, &pMem, &nLen );
SendResponseToClient( listener, SERVERDATA_CONSOLE_LOG_RESPONSE, pMem, nLen );
CloseZip( hZip );
}
else
{
LogCommand( listener, "Failed to read console log!\n" );
RespondString( listener, requestID, "Failed to read console log!\n" );
}
#endif
}
break;
#ifdef VPROF_ENABLED
case SERVERDATA_VPROF:
{
char password[25];
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
if ( IsAuthenticated(listener) )
{
RegisterVProfDataListener( listener );
LogCommand( listener, "Remote VProf started!\n" );
RespondString( listener, requestID, "Remote VProf started!\n" );
}
}
break;
case SERVERDATA_REMOVE_VPROF:
{
char password[25];
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
if ( !GetStringHelper( cmd, password, sizeof(password) ) )
{
invalidRequest = true;
break;
}
if ( IsAuthenticated(listener) )
{
RemoveVProfDataListener( listener );
LogCommand( listener, "Remote VProf finished!\n" );
RespondString( listener, requestID, "Remote VProf finished!\n" );
}
}
break;
#endif
default:
Assert(!("Unknown requestType in CServerRemoteAccess::WriteDataRequest()"));
cmd.Purge();
invalidRequest = true;
break;
};
}
}
// NOTE: This version is used by the server DLL or server plugins
void CServerRemoteAccess::WriteDataRequest( ra_listener_id listener, const void *buffer, int bufferSize )
{
WriteDataRequest( &RCONServer(), listener, buffer, bufferSize );
}
//-----------------------------------------------------------------------------
// Uploads a screenshot to a particular listener
//-----------------------------------------------------------------------------
void CServerRemoteAccess::UploadScreenshot( const char *pFileName )
{
#ifndef SWDS
if ( m_nScreenshotListener < 0 )
return;
CUtlBuffer buf( 128 * 1024, 0 );
if ( g_pFullFileSystem->ReadFile( pFileName, "MOD", buf ) )
{
HZIP hZip = CreateZipZ( 0, 1024 * 1024, ZIP_MEMORY );
void *pMem;
unsigned long nLen;
ZipAdd( hZip, "screenshot.jpg", buf.Base(), buf.TellMaxPut(), ZIP_MEMORY );
ZipGetMemory( hZip, &pMem, &nLen );
SendResponseToClient( m_nScreenshotListener, SERVERDATA_SCREENSHOT_RESPONSE, pMem, nLen );
CloseZip( hZip );
}
else
{
LogCommand( m_nScreenshotListener, "Failed to read screenshot!\n" );
RespondString( m_nScreenshotListener, 0, "Failed to read screenshot!\n" );
}
m_nScreenshotListener = -1;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: log information about a command that ran
//-----------------------------------------------------------------------------
void CServerRemoteAccess::LogCommand( ra_listener_id listener, const char *msg )
{
if ( !sv_rcon_log.GetBool() )
return;
if ( listener < (ra_listener_id)m_ListenerIDs.Count() && m_ListenerIDs[listener].m_bHasAddress )
{
Log( "rcon from \"%s\": %s\n", m_ListenerIDs[listener].adr.ToString(), msg );
}
else
{
Log( "rcon from \"unknown\": %s\n", msg );
}
}
//-----------------------------------------------------------------------------
// Purpose: checks if this user has provided the correct password
//-----------------------------------------------------------------------------
void CServerRemoteAccess::CheckPassword( CRConServer *pNetworkListener, ra_listener_id listener, int requestID, const char *password )
{
// If the pw does not match, then not authed
if ( !pNetworkListener->IsPassword( password ) )
{
BadPassword( pNetworkListener, listener );
return;
}
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listener; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// build the response
response.PutInt(requestID);
response.PutInt(SERVERDATA_AUTH_RESPONSE);
response.PutString("");
response.PutString("");
m_ListenerIDs[ listener ].authenticated = true;
}
//-----------------------------------------------------------------------------
// Purpose: returns true if this connection has provided the correct password
//-----------------------------------------------------------------------------
bool CServerRemoteAccess::IsAuthenticated( ra_listener_id listener )
{
// Checking for >= 0 is tautological because ra_listener_id is unsigned
Assert( /*listener >= 0 &&*/ listener < (ra_listener_id)m_ListenerIDs.Count() );
return m_ListenerIDs[listener].authenticated;
}
//-----------------------------------------------------------------------------
// Purpose: send a bad password packet
// Returns TRUE if socket was closed
//-----------------------------------------------------------------------------
void CServerRemoteAccess::BadPassword( CRConServer *pNetworkListener, ra_listener_id listener )
{
ListenerStore_t& listenerStore = m_ListenerIDs[listener];
listenerStore.authenticated = false;
if ( pNetworkListener->HandleFailedRconAuth( listenerStore.adr ) )
{
// Close the socket if too many failed attempts
pNetworkListener->BCloseAcceptedSocket( listener );
}
else
{
//
// Respond to the rcon user
//
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listener; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// build the response
response.PutInt(-1); // special flag for bad password
response.PutInt(SERVERDATA_AUTH_RESPONSE);
response.PutString("");
response.PutString("");
}
}
//-----------------------------------------------------------------------------
// Purpose: returns the number of bytes read
//-----------------------------------------------------------------------------
int CServerRemoteAccess::GetDataResponseSize( ra_listener_id listener )
{
for( int i = m_ResponsePackets.Head(); m_ResponsePackets.IsValidIndex(i); i = m_ResponsePackets.Next(i) )
{
// copy response into buffer
if ( m_ResponsePackets[i].responderID != listener ) // not for us, skip to the next entry
continue;
CUtlBuffer &response = m_ResponsePackets[i].packet;
return response.TellPut();
}
return 0;
}
int CServerRemoteAccess::ReadDataResponse( ra_listener_id listener, void *buffer, int bufferSize )
{
for( int i = m_ResponsePackets.Head(); m_ResponsePackets.IsValidIndex(i); i = m_ResponsePackets.Next(i) )
{
// copy response into buffer
if ( m_ResponsePackets[i].responderID != listener ) // not for us, skip to the next entry
continue;
CUtlBuffer &response = m_ResponsePackets[i].packet;
int bytesToCopy = response.TellPut();
Assert(bufferSize >= bytesToCopy);
if (bytesToCopy <= bufferSize)
{
memcpy(buffer, response.Base(), bytesToCopy);
}
else
{
// not enough room in buffer, don't return message
bytesToCopy = 0;
}
m_iBytesSent += bytesToCopy;
// ConMsg("RemoteAccess: bytes sent: %d\n", m_iBytesSent);
// remove from list
m_ResponsePackets.Remove(i);
// return bytes copied
return bytesToCopy;
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: looks up a cvar and posts a return value
//-----------------------------------------------------------------------------
void CServerRemoteAccess::RequestValue( ra_listener_id listener, int requestID, const char *variable)
{
// look up the cvar
CUtlBuffer value(0, 256, CUtlBuffer::TEXT_BUFFER); // text-mode buffer
LookupValue(variable, value);
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listener; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// build the response
response.PutInt(requestID);
response.PutInt(SERVERDATA_RESPONSE_VALUE);
response.PutString(variable);
//Assert(value.TellPut() > 0);
response.PutInt(value.TellPut());
if (value.TellPut())
{
response.Put(value.Base(), value.TellPut());
}
}
//-----------------------------------------------------------------------------
// Purpose: looks up a cvar and posts a return value
//-----------------------------------------------------------------------------
void CServerRemoteAccess::RespondString( ra_listener_id listener, int requestID, const char *pString )
{
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listener; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// build the response
response.PutInt(requestID);
response.PutInt(SERVERDATA_RESPONSE_STRING);
response.PutString(pString);
}
//-----------------------------------------------------------------------------
// Purpose: Sets a cvar or value
//-----------------------------------------------------------------------------
void CServerRemoteAccess::SetValue(const char *variable, const char *value)
{
// check for special types
if (!stricmp(variable, "map"))
{
// push a map change command
Cbuf_AddText( va( "changelevel %s\n", value ) );
Cbuf_Execute();
}
else if (!stricmp(variable, "mapcycle"))
{
// write out a new mapcycle file
ConVarRef mapcycle( "mapcyclefile" );
if ( mapcycle.IsValid() )
{
FileHandle_t f = g_pFileSystem->Open(mapcycle.GetString(), "wt");
if (!f)
{
// mapcycle file probably read only, fall pack to temporary file
Msg("Couldn't write to read-only file %s, using file _temp_mapcycle.txt instead.\n", mapcycle.GetString());
mapcycle.SetValue("_temp_mapcycle.txt" );
f = g_pFileSystem->Open(mapcycle.GetString(), "wt");
if (!f)
{
return;
}
}
g_pFileSystem->Write(value, Q_strlen(value) + 1, f);
g_pFileSystem->Close(f);
}
}
else
{
// Stick the cvar set in the command string, so client notification, replication, etc happens
Cbuf_AddText( va("%s %s", variable, value) );
Cbuf_AddText("\n");
Cbuf_Execute();
}
}
//-----------------------------------------------------------------------------
// Purpose: execs a command
//-----------------------------------------------------------------------------
void CServerRemoteAccess::ExecCommand(const char *cmdString)
{
Cbuf_AddText((char *)cmdString);
Cbuf_AddText("\n");
Cbuf_Execute();
}
//-----------------------------------------------------------------------------
// Purpose: Finds the value of a particular server variable
//-----------------------------------------------------------------------------
bool CServerRemoteAccess::LookupValue(const char *variable, CUtlBuffer &value)
{
Assert(value.IsText());
// first see if it's a cvar
const char *strval = LookupStringValue(variable);
if (strval)
{
value.PutString(strval);
value.PutChar(0);
}
else if (!stricmp(variable, "stats"))
{
char szStats[512];
GetStatsString( szStats, sizeof( szStats ) );
value.PutString( szStats );
value.PutChar(0);
}
else if (!stricmp(variable, "banlist"))
{
// returns a list of banned users and ip's
GetUserBanList(value);
}
else if (!stricmp(variable, "playerlist"))
{
GetPlayerList(value);
}
else if (!stricmp(variable, "maplist"))
{
GetMapList(value);
}
else if (!stricmp(variable, "uptime"))
{
int timeSeconds = (int)(Plat_FloatTime());
value.PutInt(timeSeconds);
value.PutChar(0);
}
else if (!stricmp(variable, "ipaddress"))
{
char addr[25];
Q_snprintf( addr, sizeof(addr), "%s:%i", net_local_adr.ToString(true), sv.GetUDPPort());
value.PutString( addr );
value.PutChar(0);
}
else if (!stricmp(variable, "mapcycle"))
{
ConVarRef mapcycle( "mapcyclefile" );
if ( mapcycle.IsValid() )
{
// send the mapcycle list file
FileHandle_t f = g_pFileSystem->Open(mapcycle.GetString(), "rb" );
if ( f == FILESYSTEM_INVALID_HANDLE )
return true;
int len = g_pFileSystem->Size(f);
char *mapcycleData = (char *)_alloca( len+1 );
if ( len && g_pFileSystem->Read( mapcycleData, len, f ) )
{
mapcycleData[len] = 0; // Make sure it's null terminated.
value.PutString((const char *)mapcycleData);
value.PutChar(0);
}
else
{
value.PutString( "" );
value.PutChar(0);
}
g_pFileSystem->Close( f );
}
}
else
{
// value not found, null terminate
value.PutChar(0);
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the value of a particular server variable for simple string values
//-----------------------------------------------------------------------------
const char *CServerRemoteAccess::LookupStringValue(const char *variable)
{
static char s_ReturnBuf[32];
IConVar *pVar = g_pCVar->FindVar( variable );
if ( pVar )
{
ConVarRef var( pVar );
if ( var.IsValid() )
return var.GetString();
}
// special types
if ( !Q_stricmp( variable, "map" ) )
return sv.GetMapName();
if ( !Q_stricmp( variable, "playercount" ) )
{
Q_snprintf( s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", sv.GetNumClients() - sv.GetNumProxies());
return s_ReturnBuf;
}
if ( !Q_stricmp( variable, "maxplayers" ) )
{
Q_snprintf( s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", sv.GetMaxClients() );
return s_ReturnBuf;
}
if ( !Q_stricmp( variable, "gamedescription" ) && serverGameDLL )
return serverGameDLL->GetGameDescription();
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: fills a buffer with a list of all banned IP addresses
//-----------------------------------------------------------------------------
void CServerRemoteAccess::GetUserBanList(CUtlBuffer &value)
{
// add user bans
int i;
for (i = 0; i < g_UserFilters.Count(); i++)
{
value.Printf("%i %s : %.3f min\n", i + 1, GetUserIDString(g_UserFilters[i].userid), g_UserFilters[i].banTime);
}
// add ip filters
for (i = 0; i < g_IPFilters.Count() ; i++)
{
unsigned char b[4];
*(unsigned *)b = g_IPFilters[i].compare;
value.Printf("%i %i.%i.%i.%i : %.3f min\n", i + 1 + g_UserFilters.Count(), b[0], b[1], b[2], b[3], g_IPFilters[i].banTime);
}
value.PutChar(0);
}
void CServerRemoteAccess::GetStatsString(char *buf, int bufSize)
{
float avgIn=0,avgOut=0;
sv.GetNetStats( avgIn, avgOut );
// format: CPU percent, Bandwidth in, Bandwidth out, uptime, changelevels, framerate, total players
_snprintf(buf, bufSize - 1, "%-6.2f %-10.2f %-11.2f %-7i %-12i %-8.2f %-8i %-8i",
sv.GetCPUUsage() * 100,
avgIn / 1024.0f,
avgOut / 1024.0f,
(int)(Sys_FloatTime()) / 60,
sv.GetSpawnCount() - 1,
1.0/host_frametime, // frame rate
sv.GetNumClients() - sv.GetNumProxies(),
sv.GetNumConnections());
buf[bufSize - 1] = 0;
};
//-----------------------------------------------------------------------------
// Purpose: Fills buffer with details on everyone in the server
//-----------------------------------------------------------------------------
void CServerRemoteAccess::GetPlayerList(CUtlBuffer &value)
{
if ( !serverGameClients )
{
return;
}
for ( int i=0 ; i< sv.GetClientCount() ; i++ )
{
CGameClient *client = sv.Client(i);
if ( !client || !client->IsActive() )
continue;
CPlayerState *pl = serverGameClients->GetPlayerState( client->edict );
if ( !pl )
continue;
// valid user, add to buffer
// format per user, each user seperated by a newline '\n'
// "name authID ipAddress ping loss frags time"
if ( client->IsFakeClient() )
{
value.Printf("\"%s\" %s 0 0 0 %d 0\n",
client->GetClientName(),
client->GetNetworkIDString(),
pl->frags);
}
else
{
value.Printf("\"%s\" %s %s %d %d %d %d\n",
client->GetClientName(),
client->GetNetworkIDString(),
client->GetNetChannel()->GetAddress(),
(int)(client->GetNetChannel()->GetAvgLatency(FLOW_OUTGOING) * 1000.0f),
(int)(client->GetNetChannel()->GetAvgLoss(FLOW_INCOMING)),
pl->frags,
(int)(client->GetNetChannel()->GetTimeConnected()));
}
}
value.PutChar(0);
}
//-----------------------------------------------------------------------------
// Purpose: Fills buffer with list of maps from this mod
//-----------------------------------------------------------------------------
void CServerRemoteAccess::GetMapList(CUtlBuffer &value)
{
// search the directory structure.
char mapwild[MAX_QPATH];
char friendly_com_gamedir[ MAX_OSPATH ];
strcpy(mapwild, "maps/*.bsp");
Q_strncpy( friendly_com_gamedir, com_gamedir, sizeof(friendly_com_gamedir) );
Q_strlower( friendly_com_gamedir );
char const *findfn = Sys_FindFirst( mapwild, NULL, 0 );
while ( findfn )
{
char curDir[MAX_PATH];
_snprintf(curDir, MAX_PATH, "maps/%s", findfn);
g_pFileSystem->GetLocalPath(curDir, curDir, MAX_PATH);
// limit maps displayed to ones for the mod only
if (strstr(curDir, friendly_com_gamedir))
{
// clean up the map name
char mapName[MAX_PATH];
strcpy(mapName, findfn);
char *extension = strstr(mapName, ".bsp");
if (extension)
{
*extension = 0;
}
// write into buffer
value.PutString(mapName);
value.PutString("\n");
}
findfn = Sys_FindNext( NULL, 0 );
}
Sys_FindClose();
value.PutChar(0);
}
//-----------------------------------------------------------------------------
// Purpose: sends a message to all the watching admin UI's
//-----------------------------------------------------------------------------
void CServerRemoteAccess::SendMessageToAdminUI( ra_listener_id listenerID, const char *message)
{
if ( listenerID != m_AdminUIID )
{
Warning( "ServerRemoteAccess: Sending AdminUI message to non-AdminUI listener\n" );
}
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listenerID; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// post the message
response.PutInt(0);
response.PutInt(SERVERDATA_UPDATE);
response.PutString(message);
}
//-----------------------------------------------------------------------------
// Purpose: Sends a response to the client
//-----------------------------------------------------------------------------
void CServerRemoteAccess::SendResponseToClient( ra_listener_id listenerID, ServerDataResponseType_t type, void *pData, int nDataLen )
{
// allocate a spot in the list for the response
int i = m_ResponsePackets.AddToTail();
m_ResponsePackets[i].responderID = listenerID; // record who we need to respond to
CUtlBuffer &response = m_ResponsePackets[i].packet;
// post the message
response.PutInt( 0 );
response.PutInt( type );
response.PutInt( nDataLen );
response.Put( pData, nDataLen );
}
//-----------------------------------------------------------------------------
// Purpose: sends an opaque blob of data from VProf to a remote rcon listener
//-----------------------------------------------------------------------------
void CServerRemoteAccess::SendVProfData( ra_listener_id listenerID, bool bGroupData, void *data, int len )
{
Assert( listenerID != m_AdminUIID ); // only RCON clients support this right now
SendResponseToClient( listenerID, bGroupData ? SERVERDATA_VPROF_GROUPS : SERVERDATA_VPROF_DATA, data, len );
}
//-----------------------------------------------------------------------------
// Purpose: C function for rest of engine to access CServerRemoteAccess class
//-----------------------------------------------------------------------------
extern "C" void NotifyDedicatedServerUI(const char *message)
{
if ( g_ServerRemoteAccess.GetAdminUIID() != INVALID_LISTENER_ID ) // if we have an admin UI actually registered
{
g_ServerRemoteAccess.SendMessageToAdminUI( g_ServerRemoteAccess.GetAdminUIID(), message);
}
}
Reference in New Issue View Git Blame Copy Permalink