sv_main.c File Reference

#include "server.h"

Include dependency graph for sv_main.c:

Go to the source code of this file.

Defines
#define	HEARTBEAT_GAME   "QuakeArena-1"
#define	HEARTBEAT_MSEC   300*1000
#define	SV_OUTPUTBUF_LENGTH   (1024 - 16)
Functions
void	SV_AddServerCommand (client_t *client, const char *cmd)
void	SV_CalcPings (void)
qboolean	SV_CheckPaused (void)
void	SV_CheckTimeouts (void)
void	SV_ConnectionlessPacket (netadr_t from, msg_t *msg)
char *	SV_ExpandNewlines (char *in)
void	SV_FlushRedirect (char *outputbuf)
void	SV_Frame (int msec)
void	SV_MasterHeartbeat (void)
void	SV_MasterShutdown (void)
void	SV_PacketEvent (netadr_t from, msg_t *msg)
int	SV_ReplacePendingServerCommands (client_t *client, const char *cmd)
void QDECL	SV_SendServerCommand (client_t *cl, const char *fmt,...)
void	SVC_Info (netadr_t from)
void	SVC_RemoteCommand (netadr_t from, msg_t *msg)
void	SVC_Status (netadr_t from)
Variables
vm_t *	gvm = NULL
server_t	sv
cvar_t *	sv_allowDownload
cvar_t *	sv_floodProtect
cvar_t *	sv_fps
cvar_t *	sv_gametype
cvar_t *	sv_hostname
cvar_t *	sv_killserver
cvar_t *	sv_lanForceRate
cvar_t *	sv_mapChecksum
cvar_t *	sv_mapname
cvar_t *	sv_master [MAX_MASTER_SERVERS]
cvar_t *	sv_maxclients
cvar_t *	sv_maxPing
cvar_t *	sv_maxRate
cvar_t *	sv_minPing
cvar_t *	sv_padPackets
cvar_t *	sv_privateClients
cvar_t *	sv_privatePassword
cvar_t *	sv_pure
cvar_t *	sv_rconPassword
cvar_t *	sv_reconnectlimit
cvar_t *	sv_serverid
cvar_t *	sv_showloss
cvar_t *	sv_strictAuth
cvar_t *	sv_timeout
cvar_t *	sv_zombietime
serverStatic_t	svs

---

Define Documentation

#define HEARTBEAT_GAME   "QuakeArena-1"

Definition at line 215 of file sv_main.c. Referenced by SV_MasterHeartbeat().

#define HEARTBEAT_MSEC   300*1000

Definition at line 214 of file sv_main.c.

#define SV_OUTPUTBUF_LENGTH   (1024 - 16)

Referenced by SVC_RemoteCommand().

---

Function Documentation

void SV_AddServerCommand (  client_t *  client, const char *  cmd )

Definition at line 128 of file sv_main.c. References client_t, Com_Printf(), i, MAX_RELIABLE_COMMANDS, Q_strncpyz(), client_s::reliableAcknowledge, client_s::reliableCommands, client_s::reliableSequence, and SV_DropClient(). Referenced by SV_MapRestart_f(), and SV_SendServerCommand(). { int index, i; // this is very ugly but it's also a waste to for instance send multiple config string updates // for the same config string index in one snapshot // if ( SV_ReplacePendingServerCommands( client, cmd ) ) { // return; // } client->reliableSequence++; // if we would be losing an old command that hasn't been acknowledged, // we must drop the connection // we check == instead of >= so a broadcast print added by SV_DropClient() // doesn't cause a recursive drop client if ( client->reliableSequence - client->reliableAcknowledge == MAX_RELIABLE_COMMANDS + 1 ) { Com_Printf( "===== pending server commands =====\n" ); for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) { Com_Printf( "cmd %5d: %s\n", i, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] ); } Com_Printf( "cmd %5d: %s\n", i, cmd ); SV_DropClient( client, "Server command overflow" ); return; } index = client->reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 ); Q_strncpyz( client->reliableCommands[ index ], cmd, sizeof( client->reliableCommands[ index ] ) ); }

Here is the call graph for this function:

void SV_CalcPings (  void   )

Definition at line 613 of file sv_main.c. References cl, client_t, serverStatic_t::clients, count, i, cvar_s::integer, j, playerState_s::ping, playerState_t, SV_GameClientNum(), sv_maxclients, and svs. Referenced by SV_Frame(). { int i, j; client_t *cl; int total, count; int delta; playerState_t *ps; for (i=0 ; i < sv_maxclients->integer ; i++) { cl = &svs.clients[i]; if ( cl->state != CS_ACTIVE ) { cl->ping = 999; continue; } if ( !cl->gentity ) { cl->ping = 999; continue; } if ( cl->gentity->r.svFlags & SVF_BOT ) { cl->ping = 0; continue; } total = 0; count = 0; for ( j = 0 ; j < PACKET_BACKUP ; j++ ) { if ( cl->frames[j].messageAcked <= 0 ) { continue; } delta = cl->frames[j].messageAcked - cl->frames[j].messageSent; count++; total += delta; } if (!count) { cl->ping = 999; } else { cl->ping = total/count; if ( cl->ping > 999 ) { cl->ping = 999; } } // let the game dll know about the ping ps = SV_GameClientNum( i ); ps->ping = cl->ping; } }

Here is the call graph for this function:

qboolean SV_CheckPaused (  void   )

Definition at line 714 of file sv_main.c. References cl, cl_paused, client_t, serverStatic_t::clients, count, CS_CONNECTED, Cvar_Set(), i, cvar_s::integer, qboolean, sv_maxclients, sv_paused, and svs. Referenced by SV_Frame(). { int count; client_t *cl; int i; if ( !cl_paused->integer ) { return qfalse; } // only pause if there is just a single client connected count = 0; for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) { if ( cl->state >= CS_CONNECTED && cl->netchan.remoteAddress.type != NA_BOT ) { count++; } } if ( count > 1 ) { // don't pause if (sv_paused->integer) Cvar_Set("sv_paused", "0"); return qfalse; } if (!sv_paused->integer) Cvar_Set("sv_paused", "1"); return qtrue; }

Here is the call graph for this function:

void SV_CheckTimeouts (  void   )

Definition at line 673 of file sv_main.c. References cl, client_t, serverStatic_t::clients, Com_DPrintf(), CS_CONNECTED, CS_ZOMBIE, i, cvar_s::integer, SV_DropClient(), sv_maxclients, sv_timeout, sv_zombietime, svs, and serverStatic_t::time. Referenced by SV_Frame(). { int i; client_t *cl; int droppoint; int zombiepoint; droppoint = svs.time - 1000 * sv_timeout->integer; zombiepoint = svs.time - 1000 * sv_zombietime->integer; for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) { // message times may be wrong across a changelevel if (cl->lastPacketTime > svs.time) { cl->lastPacketTime = svs.time; } if (cl->state == CS_ZOMBIE && cl->lastPacketTime < zombiepoint) { // using the client id cause the cl->name is empty at this point Com_DPrintf( "Going from CS_ZOMBIE to CS_FREE for client %d\n", i ); cl->state = CS_FREE; // can now be reused continue; } if ( cl->state >= CS_CONNECTED && cl->lastPacketTime < droppoint) { // wait several frames so a debugger session doesn't // cause a timeout if ( ++cl->timeoutCount > 5 ) { SV_DropClient (cl, "timed out"); cl->state = CS_FREE; // don't bother with zombie state } } else { cl->timeoutCount = 0; } } }

Here is the call graph for this function:

void SV_ConnectionlessPacket (  netadr_t  from, msg_t *  msg )

Definition at line 502 of file sv_main.c. References c, Cmd_Argv(), Cmd_TokenizeString(), Com_DPrintf(), msg_t::data, Huff_Decompress(), MSG_BeginReadingOOB(), MSG_ReadLong(), MSG_ReadStringLine(), NET_AdrToString(), Q_stricmp(), Q_strncmp(), s, SV_AuthorizeIpPacket(), SV_DirectConnect(), SV_GetChallenge(), SVC_Info(), SVC_RemoteCommand(), and SVC_Status(). Referenced by SV_PacketEvent(). { char *s; char *c; MSG_BeginReadingOOB( msg ); MSG_ReadLong( msg ); // skip the -1 marker if (!Q_strncmp("connect", &msg->data[4], 7)) { Huff_Decompress(msg, 12); } s = MSG_ReadStringLine( msg ); Cmd_TokenizeString( s ); c = Cmd_Argv(0); Com_DPrintf ("SV packet %s : %s\n", NET_AdrToString(from), c); if (!Q_stricmp(c, "getstatus")) { SVC_Status( from ); } else if (!Q_stricmp(c, "getinfo")) { SVC_Info( from ); } else if (!Q_stricmp(c, "getchallenge")) { SV_GetChallenge( from ); } else if (!Q_stricmp(c, "connect")) { SV_DirectConnect( from ); } else if (!Q_stricmp(c, "ipAuthorize")) { SV_AuthorizeIpPacket( from ); } else if (!Q_stricmp(c, "rcon")) { SVC_RemoteCommand( from, msg ); } else if (!Q_stricmp(c, "disconnect")) { // if a client starts up a local server, we may see some spurious // server disconnect messages when their new server sees our final // sequenced messages to the old client } else { Com_DPrintf ("bad connectionless packet from %s:\n%s\n" , NET_AdrToString (from), s); } }

Here is the call graph for this function:

char* SV_ExpandNewlines (  char *  in  )

Definition at line 71 of file sv_main.c. References in, l, and string(). Referenced by SV_SendServerCommand(). { static char string[1024]; int l; l = 0; while ( *in && l < sizeof(string) - 3 ) { if ( *in == '\n' ) { string[l++] = '\\'; string[l++] = 'n'; } else { string[l++] = *in; } in++; } string[l] = 0; return string; }

Here is the call graph for this function:

void SV_FlushRedirect (  char *  outputbuf  )

Definition at line 419 of file sv_main.c. References NET_OutOfBandPrint(), NS_SERVER, serverStatic_t::redirectAddress, and svs. Referenced by SVC_RemoteCommand(). { NET_OutOfBandPrint( NS_SERVER, svs.redirectAddress, "print\n%s", outputbuf ); }

Here is the call graph for this function:

void SV_Frame (  int  msec  )

Definition at line 751 of file sv_main.c. References Cbuf_AddText(), com_dedicated, com_speeds, com_sv_running, CS_SERVERINFO, CS_SYSTEMINFO, Cvar_InfoString(), Cvar_InfoString_Big(), cvar_modifiedFlags, CVAR_SERVERINFO, Cvar_Set(), CVAR_SYSTEMINFO, GAME_RUN_FRAME, gvm, cvar_s::integer, NET_Sleep(), serverStatic_t::nextSnapshotEntities, serverStatic_t::numSnapshotEntities, server_t::restartTime, startTime, sv, SV_BotFrame(), SV_CalcPings(), SV_CheckPaused(), SV_CheckTimeouts(), sv_fps, sv_killserver, SV_MasterHeartbeat(), SV_SendClientMessages(), SV_SetConfigstring(), SV_Shutdown(), svs, Sys_Milliseconds(), serverStatic_t::time, time_game, server_t::timeResidual, and VM_Call(). Referenced by CL_Connect_f(), and Com_Frame(). { int frameMsec; int startTime; // the menu kills the server with this cvar if ( sv_killserver->integer ) { SV_Shutdown ("Server was killed.\n"); Cvar_Set( "sv_killserver", "0" ); return; } if ( !com_sv_running->integer ) { return; } // allow pause if only the local client is connected if ( SV_CheckPaused() ) { return; } // if it isn't time for the next frame, do nothing if ( sv_fps->integer < 1 ) { Cvar_Set( "sv_fps", "10" ); } frameMsec = 1000 / sv_fps->integer ; sv.timeResidual += msec; if (!com_dedicated->integer) SV_BotFrame( svs.time + sv.timeResidual ); if ( com_dedicated->integer && sv.timeResidual < frameMsec ) { // NET_Sleep will give the OS time slices until either get a packet // or time enough for a server frame has gone by NET_Sleep(frameMsec - sv.timeResidual); return; } // if time is about to hit the 32nd bit, kick all clients // and clear sv.time, rather // than checking for negative time wraparound everywhere. // 2giga-milliseconds = 23 days, so it won't be too often if ( svs.time > 0x70000000 ) { SV_Shutdown( "Restarting server due to time wrapping" ); Cbuf_AddText( "vstr nextmap\n" ); return; } // this can happen considerably earlier when lots of clients play and the map doesn't change if ( svs.nextSnapshotEntities >= 0x7FFFFFFE - svs.numSnapshotEntities ) { SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" ); Cbuf_AddText( "vstr nextmap\n" ); return; } if( sv.restartTime && svs.time >= sv.restartTime ) { sv.restartTime = 0; Cbuf_AddText( "map_restart 0\n" ); return; } // update infostrings if anything has been changed if ( cvar_modifiedFlags & CVAR_SERVERINFO ) { SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) ); cvar_modifiedFlags &= ~CVAR_SERVERINFO; } if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) { SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString_Big( CVAR_SYSTEMINFO ) ); cvar_modifiedFlags &= ~CVAR_SYSTEMINFO; } if ( com_speeds->integer ) { startTime = Sys_Milliseconds (); } else { startTime = 0; // quite a compiler warning } // update ping based on the all received frames SV_CalcPings(); if (com_dedicated->integer) SV_BotFrame( svs.time ); // run the game simulation in chunks while ( sv.timeResidual >= frameMsec ) { sv.timeResidual -= frameMsec; svs.time += frameMsec; // let everything in the world think and move VM_Call( gvm, GAME_RUN_FRAME, svs.time ); } if ( com_speeds->integer ) { time_game = Sys_Milliseconds () - startTime; } // check timeouts SV_CheckTimeouts(); // send messages back to the clients SV_SendClientMessages(); // send a heartbeat to the master if needed SV_MasterHeartbeat(); }

Here is the call graph for this function:

void SV_MasterHeartbeat (  void   )

Definition at line 216 of file sv_main.c. References BigShort(), com_dedicated, Com_Printf(), Cvar_Set(), HEARTBEAT_GAME, i, cvar_s::integer, cvar_s::modified, name, NET_OutOfBandPrint(), NET_StringToAdr(), serverStatic_t::nextHeartbeatTime, NS_SERVER, netadr_t::port, PORT_MASTER, string(), cvar_s::string, strstr(), sv_master, svs, and serverStatic_t::time. Referenced by SV_Frame(), and SV_MasterShutdown(). { static netadr_t adr[MAX_MASTER_SERVERS]; int i; // "dedicated 1" is for lan play, "dedicated 2" is for inet public play if ( !com_dedicated || com_dedicated->integer != 2 ) { return; // only dedicated servers send heartbeats } // if not time yet, don't send anything if ( svs.time < svs.nextHeartbeatTime ) { return; } svs.nextHeartbeatTime = svs.time + HEARTBEAT_MSEC; // send to group masters for ( i = 0 ; i < MAX_MASTER_SERVERS ; i++ ) { if ( !sv_master[i]->string[0] ) { continue; } // see if we haven't already resolved the name // resolving usually causes hitches on win95, so only // do it when needed if ( sv_master[i]->modified ) { sv_master[i]->modified = qfalse; Com_Printf( "Resolving %s\n", sv_master[i]->string ); if ( !NET_StringToAdr( sv_master[i]->string, &adr[i] ) ) { // if the address failed to resolve, clear it // so we don't take repeated dns hits Com_Printf( "Couldn't resolve address: %s\n", sv_master[i]->string ); Cvar_Set( sv_master[i]->name, "" ); sv_master[i]->modified = qfalse; continue; } if ( !strstr( ":", sv_master[i]->string ) ) { adr[i].port = BigShort( PORT_MASTER ); } Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", sv_master[i]->string, adr[i].ip[0], adr[i].ip[1], adr[i].ip[2], adr[i].ip[3], BigShort( adr[i].port ) ); } Com_Printf ("Sending heartbeat to %s\n", sv_master[i]->string ); // this command should be changed if the server info / status format // ever incompatably changes NET_OutOfBandPrint( NS_SERVER, adr[i], "heartbeat %s\n", HEARTBEAT_GAME ); } }

Here is the call graph for this function:

void SV_MasterShutdown (  void   )

Definition at line 276 of file sv_main.c. References serverStatic_t::nextHeartbeatTime, SV_MasterHeartbeat(), and svs. Referenced by SV_Shutdown(). { // send a hearbeat right now svs.nextHeartbeatTime = -9999; SV_MasterHeartbeat(); // send it again to minimize chance of drops svs.nextHeartbeatTime = -9999; SV_MasterHeartbeat(); // when the master tries to poll the server, it won't respond, so // it will be removed from the list }

Here is the call graph for this function:

void SV_PacketEvent (  netadr_t  from, msg_t *  msg )

Definition at line 548 of file sv_main.c. References cl, client_t, serverStatic_t::clients, Com_Printf(), msg_t::cursize, msg_t::data, i, cvar_s::integer, MSG_BeginReadingOOB(), MSG_ReadLong(), MSG_ReadShort(), NET_CompareBaseAdr(), NET_OutOfBandPrint(), NS_SERVER, netadr_t::port, qport, SV_ConnectionlessPacket(), SV_ExecuteClientMessage(), sv_maxclients, SV_Netchan_Process(), svs, and serverStatic_t::time. Referenced by Com_RunAndTimeServerPacket(). { int i; client_t *cl; int qport; // check for connectionless packet (0xffffffff) first if ( msg->cursize >= 4 && *(int *)msg->data == -1) { SV_ConnectionlessPacket( from, msg ); return; } // read the qport out of the message so we can fix up // stupid address translating routers MSG_BeginReadingOOB( msg ); MSG_ReadLong( msg ); // sequence number qport = MSG_ReadShort( msg ) & 0xffff; // find which client the message is from for (i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) { if (cl->state == CS_FREE) { continue; } if ( !NET_CompareBaseAdr( from, cl->netchan.remoteAddress ) ) { continue; } // it is possible to have multiple clients from a single IP // address, so they are differentiated by the qport variable if (cl->netchan.qport != qport) { continue; } // the IP port can't be used to differentiate them, because // some address translating routers periodically change UDP // port assignments if (cl->netchan.remoteAddress.port != from.port) { Com_Printf( "SV_PacketEvent: fixing up a translated port\n" ); cl->netchan.remoteAddress.port = from.port; } // make sure it is a valid, in sequence packet if (SV_Netchan_Process(cl, msg)) { // zombie clients still need to do the Netchan_Process // to make sure they don't need to retransmit the final // reliable message, but they don't do any other processing if (cl->state != CS_ZOMBIE) { cl->lastPacketTime = svs.time; // don't timeout SV_ExecuteClientMessage( cl, msg ); } } return; } // if we received a sequenced packet from an address we don't recognize, // send an out of band disconnect packet to it NET_OutOfBandPrint( NS_SERVER, from, "disconnect" ); }

Here is the call graph for this function:

int SV_ReplacePendingServerCommands (  client_t *  client, const char *  cmd )

Definition at line 97 of file sv_main.c. References client_t, i, MAX_RELIABLE_COMMANDS, Q_strncmp(), Q_strncpyz(), client_s::reliableCommands, client_s::reliableSent, client_s::reliableSequence, sscanf(), and strlen(). { int i, index, csnum1, csnum2; for ( i = client->reliableSent+1; i <= client->reliableSequence; i++ ) { index = i & ( MAX_RELIABLE_COMMANDS - 1 ); // if ( !Q_strncmp(cmd, client->reliableCommands[ index ], strlen("cs")) ) { sscanf(cmd, "cs %i", &csnum1); sscanf(client->reliableCommands[ index ], "cs %i", &csnum2); if ( csnum1 == csnum2 ) { Q_strncpyz( client->reliableCommands[ index ], cmd, sizeof( client->reliableCommands[ index ] ) ); /* if ( client->netchan.remoteAddress.type != NA_BOT ) { Com_Printf( "WARNING: client %i removed double pending config string %i: %s\n", client-svs.clients, csnum1, cmd ); } */ return qtrue; } } } return qfalse; }

Here is the call graph for this function:

void QDECL SV_SendServerCommand (  client_t *  cl, const char *  fmt,   ... )

Definition at line 165 of file sv_main.c. References byte, cl, client_t, serverStatic_t::clients, com_dedicated, Com_Printf(), cvar_s::integer, j, Q_vsnprintf, QDECL, client_s::state, strncmp(), SV_AddServerCommand(), SV_ExpandNewlines(), sv_maxclients, svs, va_end, va_list, and va_start. Referenced by SV_Ban_f(), SV_BanNum_f(), SV_ConSay_f(), SV_DropClient(), SV_FinalMessage(), SV_GameSendServerCommand(), SV_Kick_f(), SV_KickNum_f(), and SV_SetConfigstring(). { va_list argptr; byte message[MAX_MSGLEN]; client_t *client; int j; va_start (argptr,fmt); Q_vsnprintf ((char *)message, sizeof(message), fmt,argptr); va_end (argptr); if ( cl != NULL ) { SV_AddServerCommand( cl, (char *)message ); return; } // hack to echo broadcast prints to console if ( com_dedicated->integer && !strncmp( (char *)message, "print", 5) ) { Com_Printf ("broadcast: %s\n", SV_ExpandNewlines((char *)message) ); } // send the data to all relevent clients for (j = 0, client = svs.clients; j < sv_maxclients->integer ; j++, client++) { if ( client->state < CS_PRIMED ) { continue; } SV_AddServerCommand( client, (char *)message ); } }

Here is the call graph for this function:

void SVC_Info (  netadr_t  from  )

Definition at line 366 of file sv_main.c. References serverStatic_t::clients, Cmd_Argv(), count, Cvar_VariableString(), Cvar_VariableValue(), gamedir, GT_SINGLE_PLAYER, i, Info_SetValueForKey(), cvar_s::integer, NET_OutOfBandPrint(), NS_SERVER, PROTOCOL_VERSION, client_s::state, cvar_s::string, sv_gametype, sv_hostname, sv_mapname, sv_maxclients, sv_maxPing, sv_minPing, sv_privateClients, sv_pure, svs, and va(). Referenced by SV_ConnectionlessPacket(). { int i, count; char *gamedir; char infostring[MAX_INFO_STRING]; // ignore if we are in single player if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER || Cvar_VariableValue("ui_singlePlayerActive")) { return; } // don't count privateclients count = 0; for ( i = sv_privateClients->integer ; i < sv_maxclients->integer ; i++ ) { if ( svs.clients[i].state >= CS_CONNECTED ) { count++; } } infostring[0] = 0; // echo back the parameter to status. so servers can use it as a challenge // to prevent timed spoofed reply packets that add ghost servers Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) ); Info_SetValueForKey( infostring, "protocol", va("%i", PROTOCOL_VERSION) ); Info_SetValueForKey( infostring, "hostname", sv_hostname->string ); Info_SetValueForKey( infostring, "mapname", sv_mapname->string ); Info_SetValueForKey( infostring, "clients", va("%i", count) ); Info_SetValueForKey( infostring, "sv_maxclients", va("%i", sv_maxclients->integer - sv_privateClients->integer ) ); Info_SetValueForKey( infostring, "gametype", va("%i", sv_gametype->integer ) ); Info_SetValueForKey( infostring, "pure", va("%i", sv_pure->integer ) ); if( sv_minPing->integer ) { Info_SetValueForKey( infostring, "minPing", va("%i", sv_minPing->integer) ); } if( sv_maxPing->integer ) { Info_SetValueForKey( infostring, "maxPing", va("%i", sv_maxPing->integer) ); } gamedir = Cvar_VariableString( "fs_game" ); if( *gamedir ) { Info_SetValueForKey( infostring, "game", gamedir ); } NET_OutOfBandPrint( NS_SERVER, from, "infoResponse\n%s", infostring ); }

Here is the call graph for this function:

void SVC_RemoteCommand (  netadr_t  from, msg_t *  msg )

Definition at line 432 of file sv_main.c. References Cmd_Argv(), Cmd_Cmd(), Cmd_ExecuteString(), Com_BeginRedirect(), Com_EndRedirect(), Com_Milliseconds(), Com_Printf(), NET_AdrToString(), Q_strcat(), qboolean, serverStatic_t::redirectAddress, strcmp(), cvar_s::string, strlen(), SV_FlushRedirect(), SV_OUTPUTBUF_LENGTH, sv_rconPassword, svs, and time(). Referenced by SV_ConnectionlessPacket(). { qboolean valid; unsigned int time; char remaining[1024]; // TTimo - scaled down to accumulate, but not overflow anything network wise, print wise etc. // (OOB messages are the bottleneck here) #define SV_OUTPUTBUF_LENGTH (1024 - 16) char sv_outputbuf[SV_OUTPUTBUF_LENGTH]; static unsigned int lasttime = 0; char *cmd_aux; // TTimo - https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=534 time = Com_Milliseconds(); if (time<(lasttime+500)) { return; } lasttime = time; if ( !strlen( sv_rconPassword->string ) || strcmp (Cmd_Argv(1), sv_rconPassword->string) ) { valid = qfalse; Com_Printf ("Bad rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) ); } else { valid = qtrue; Com_Printf ("Rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) ); } // start redirecting all print outputs to the packet svs.redirectAddress = from; Com_BeginRedirect (sv_outputbuf, SV_OUTPUTBUF_LENGTH, SV_FlushRedirect); if ( !strlen( sv_rconPassword->string ) ) { Com_Printf ("No rconpassword set on the server.\n"); } else if ( !valid ) { Com_Printf ("Bad rconpassword.\n"); } else { remaining[0] = 0; // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543 // get the command directly, "rcon <pass> <command>" to avoid quoting issues // extract the command by walking // since the cmd formatting can fuckup (amount of spaces), using a dumb step by step parsing cmd_aux = Cmd_Cmd(); cmd_aux+=4; while(cmd_aux[0]==' ') cmd_aux++; while(cmd_aux[0] && cmd_aux[0]!=' ') // password cmd_aux++; while(cmd_aux[0]==' ') cmd_aux++; Q_strcat( remaining, sizeof(remaining), cmd_aux); Cmd_ExecuteString (remaining); } Com_EndRedirect (); }

Here is the call graph for this function:

void SVC_Status (  netadr_t  from  )

Definition at line 307 of file sv_main.c. References cl, client_t, serverStatic_t::clients, Cmd_Argv(), Com_sprintf(), Cvar_InfoString(), CVAR_SERVERINFO, Cvar_VariableValue(), i, Info_SetValueForKey(), Info_ValueForKey(), cvar_s::integer, NET_OutOfBandPrint(), NS_SERVER, PERS_SCORE, playerState_s::persistant, playerState_t, strcpy(), strlen(), SV_GameClientNum(), sv_maxclients, and svs. Referenced by SV_ConnectionlessPacket(). { char player[1024]; char status[MAX_MSGLEN]; int i; client_t *cl; playerState_t *ps; int statusLength; int playerLength; char infostring[MAX_INFO_STRING]; // ignore if we are in single player if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER ) { return; } strcpy( infostring, Cvar_InfoString( CVAR_SERVERINFO ) ); // echo back the parameter to status. so master servers can use it as a challenge // to prevent timed spoofed reply packets that add ghost servers Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) ); // add "demo" to the sv_keywords if restricted if ( Cvar_VariableValue( "fs_restrict" ) ) { char keywords[MAX_INFO_STRING]; Com_sprintf( keywords, sizeof( keywords ), "demo %s", Info_ValueForKey( infostring, "sv_keywords" ) ); Info_SetValueForKey( infostring, "sv_keywords", keywords ); } status[0] = 0; statusLength = 0; for (i=0 ; i < sv_maxclients->integer ; i++) { cl = &svs.