sv_client.c File Reference

#include "server.h"

Include dependency graph for sv_client.c:

Go to the source code of this file.

Data Structures
struct	ucmd_t
Defines
#define	PB_MESSAGE
Functions
void	SV_AuthorizeIpPacket (netadr_t from)
void	SV_BeginDownload_f (client_t *cl)
qboolean	SV_ClientCommand (client_t *cl, msg_t *msg)
void	SV_ClientEnterWorld (client_t *client, usercmd_t *cmd)
void	SV_ClientThink (client_t *cl, usercmd_t *cmd)
void	SV_CloseDownload (client_t *cl)
void	SV_DirectConnect (netadr_t from)
void	SV_Disconnect_f (client_t *cl)
void	SV_DoneDownload_f (client_t *cl)
void	SV_DropClient (client_t *drop, const char *reason)
void	SV_ExecuteClientCommand (client_t *cl, const char *s, qboolean clientOK)
void	SV_ExecuteClientMessage (client_t *cl, msg_t *msg)
void	SV_GetChallenge (netadr_t from)
void	SV_NextDownload_f (client_t *cl)
void	SV_ResetPureClient_f (client_t *cl)
void	SV_SendClientGameState (client_t *client)
void	SV_StopDownload_f (client_t *cl)
void	SV_UpdateUserinfo_f (client_t *cl)
void	SV_UserinfoChanged (client_t *cl)
void	SV_UserMove (client_t *cl, msg_t *msg, qboolean delta)
void	SV_VerifyPaks_f (client_t *cl)
void	SV_WriteDownloadToClient (client_t *cl, msg_t *msg)
Variables
ucmd_t	ucmds []

---

Define Documentation

#define PB_MESSAGE

Value: "PunkBuster Anti-Cheat software must be installed " \ "and Enabled in order to join this server. An updated game patch can be downloaded from " \ "www.idsoftware.com" Definition at line 226 of file sv_client.c.

---

Function Documentation

void SV_AuthorizeIpPacket (  netadr_t  from  )

Definition at line 147 of file sv_client.c. References challenge_t::adr, atoi, serverStatic_t::authorizeAddress, challenge_t::challenge, serverStatic_t::challenges, Cmd_Argv(), Com_Memset(), Com_Printf(), Cvar_VariableValue(), i, NET_CompareBaseAdr(), NET_OutOfBandPrint(), NS_SERVER, challenge_t::pingTime, Q_stricmp(), r, s, sprintf(), svs, and serverStatic_t::time. Referenced by SV_ConnectionlessPacket(). { int challenge; int i; char *s; char *r; char ret[1024]; if ( !NET_CompareBaseAdr( from, svs.authorizeAddress ) ) { Com_Printf( "SV_AuthorizeIpPacket: not from authorize server\n" ); return; } challenge = atoi( Cmd_Argv( 1 ) ); for (i = 0 ; i < MAX_CHALLENGES ; i++) { if ( svs.challenges[i].challenge == challenge ) { break; } } if ( i == MAX_CHALLENGES ) { Com_Printf( "SV_AuthorizeIpPacket: challenge not found\n" ); return; } // send a packet back to the original client svs.challenges[i].pingTime = svs.time; s = Cmd_Argv( 2 ); r = Cmd_Argv( 3 ); // reason if ( !Q_stricmp( s, "demo" ) ) { if ( Cvar_VariableValue( "fs_restrict" ) ) { // a demo client connecting to a demo server NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "challengeResponse %i", svs.challenges[i].challenge ); return; } // they are a demo client trying to connect to a real server NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nServer is not a demo server\n" ); // clear the challenge record so it won't timeout and let them through Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) ); return; } if ( !Q_stricmp( s, "accept" ) ) { NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "challengeResponse %i", svs.challenges[i].challenge ); return; } if ( !Q_stricmp( s, "unknown" ) ) { if (!r) { NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nAwaiting CD key authorization\n" ); } else { sprintf(ret, "print\n%s\n", r); NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, ret ); } // clear the challenge record so it won't timeout and let them through Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) ); return; } // authorization failed if (!r) { NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nSomeone is using this CD Key\n" ); } else { sprintf(ret, "print\n%s\n", r); NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, ret ); } // clear the challenge record so it won't timeout and let them through Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) ); }

Here is the call graph for this function:

void SV_BeginDownload_f (  client_t *  cl  )

Definition at line 736 of file sv_client.c. References cl, client_t, Cmd_Argv(), Q_strncpyz(), and SV_CloseDownload(). { // Kill any existing download SV_CloseDownload( cl ); // cl->downloadName is non-zero now, SV_WriteDownloadToClient will see this and open // the file itself Q_strncpyz( cl->downloadName, Cmd_Argv(1), sizeof(cl->downloadName) ); }

Here is the call graph for this function:

qboolean SV_ClientCommand (  client_t *  cl, msg_t *  msg )  [static]

Definition at line 1249 of file sv_client.c. References cl, client_t, com_cl_running, Com_DPrintf(), Com_Printf(), Com_sprintf(), CS_ACTIVE, cvar_s::integer, MSG_ReadLong(), MSG_ReadString(), qboolean, s, SV_DropClient(), SV_ExecuteClientCommand(), sv_floodProtect, svs, and serverStatic_t::time. Referenced by SV_ExecuteClientMessage(). { int seq; const char *s; qboolean clientOk = qtrue; seq = MSG_ReadLong( msg ); s = MSG_ReadString( msg ); // see if we have already executed it if ( cl->lastClientCommand >= seq ) { return qtrue; } Com_DPrintf( "clientCommand: %s : %i : %s\n", cl->name, seq, s ); // drop the connection if we have somehow lost commands if ( seq > cl->lastClientCommand + 1 ) { Com_Printf( "Client %s lost %i clientCommands\n", cl->name, seq - cl->lastClientCommand + 1 ); SV_DropClient( cl, "Lost reliable commands" ); return qfalse; } // malicious users may try using too many string commands // to lag other players. If we decide that we want to stall // the command, we will stop processing the rest of the packet, // including the usercmd. This causes flooders to lag themselves // but not other people // We don't do this when the client hasn't been active yet since its // normal to spam a lot of commands when downloading if ( !com_cl_running->integer && cl->state >= CS_ACTIVE && sv_floodProtect->integer && svs.time < cl->nextReliableTime ) { // ignore any other text messages from this client but let them keep playing // TTimo - moved the ignored verbose to the actual processing in SV_ExecuteClientCommand, only printing if the core doesn't intercept clientOk = qfalse; } // don't allow another command for one second cl->nextReliableTime = svs.time + 1000; SV_ExecuteClientCommand( cl, s, clientOk ); cl->lastClientCommand = seq; Com_sprintf(cl->lastClientCommandString, sizeof(cl->lastClientCommandString), "%s", s); return qtrue; // continue procesing }

Here is the call graph for this function:

void SV_ClientEnterWorld (  client_t *  client, usercmd_t *  cmd )

Definition at line 616 of file sv_client.c. References client_t, serverStatic_t::clients, Com_DPrintf(), client_s::deltaMessage, GAME_CLIENT_BEGIN, client_s::gentity, gvm, client_s::lastUsercmd, client_s::name, client_s::nextSnapshotTime, entityState_s::number, sharedEntity_t::s, client_s::state, SV_GentityNum(), svs, serverStatic_t::time, usercmd_t, and VM_Call(). Referenced by SV_MapRestart_f(), and SV_UserMove(). { int clientNum; sharedEntity_t *ent; Com_DPrintf( "Going from CS_PRIMED to CS_ACTIVE for %s\n", client->name ); client->state = CS_ACTIVE; // set up the entity for the client clientNum = client - svs.clients; ent = SV_GentityNum( clientNum ); ent->s.number = clientNum; client->gentity = ent; client->deltaMessage = -1; client->nextSnapshotTime = svs.time; // generate a snapshot immediately client->lastUsercmd = *cmd; // call the game begin function VM_Call( gvm, GAME_CLIENT_BEGIN, client - svs.clients ); }

Here is the call graph for this function:

void SV_ClientThink (  client_t *  cl, usercmd_t *  cmd )

Definition at line 1310 of file sv_client.c. References cl, client_t, serverStatic_t::clients, GAME_CLIENT_THINK, gvm, svs, usercmd_t, and VM_Call(). Referenced by SV_GameSystemCalls(), and SV_UserMove(). { cl->lastUsercmd = *cmd; if ( cl->state != CS_ACTIVE ) { return; // may have been kicked during the last usercmd } VM_Call( gvm, GAME_CLIENT_THINK, cl - svs.clients ); }

Here is the call graph for this function:

void SV_CloseDownload (  client_t *  cl  )  [static]

Definition at line 652 of file sv_client.c. References cl, client_t, FS_FCloseFile(), i, and Z_Free(). Referenced by SV_BeginDownload_f(), SV_DropClient(), SV_NextDownload_f(), and SV_StopDownload_f(). { int i; // EOF if (cl->download) { FS_FCloseFile( cl->download ); } cl->download = 0; *cl->downloadName = 0; // Free the temporary buffer space for (i = 0; i < MAX_DOWNLOAD_WINDOW; i++) { if (cl->downloadBlocks[i]) { Z_Free( cl->downloadBlocks[i] ); cl->downloadBlocks[i] = NULL; } } }

Here is the call graph for this function:

void SV_DirectConnect (  netadr_t  from  )

Definition at line 230 of file sv_client.c. References challenge_t::adr, atoi, client_s::challenge, challenge_t::challenge, serverStatic_t::challenges, cl, client_t, serverStatic_t::clients, Cmd_Argv(), Com_DPrintf(), Com_Error(), Com_Memset(), Com_Printf(), challenge_t::connected, count, ERR_FATAL, GAME_CLIENT_CONNECT, client_s::gamestateMessageNum, client_s::gentity, gvm, i, Info_SetValueForKey(), Info_ValueForKey(), cvar_s::integer, client_s::lastConnectTime, client_s::lastPacketTime, client_s::name, NET_AdrToString(), NET_CompareAdr(), NET_CompareBaseAdr(), NET_IsLocalAddress(), NET_OutOfBandPrint(), client_s::netchan, client_s::netchan_end_queue, Netchan_Setup(), client_s::netchan_start_queue, client_s::nextSnapshotTime, NS_SERVER, challenge_t::pingTime, netadr_t::port, PROTOCOL_VERSION, Q_strncpyz(), qfalse, qport, qtrue, client_s::state, strcmp(), cvar_s::string, SV_DropClient(), SV_GentityNum(), SV_Heartbeat_f(), sv_maxclients, sv_maxPing, sv_minPing, sv_privateClients, sv_privatePassword, sv_reconnectlimit, SV_UserinfoChanged(), svs, Sys_IsLANAddress(), serverStatic_t::time, client_s::userinfo, cvar_s::value, VM_Call(), and VM_ExplicitArgPtr(). Referenced by SV_ConnectionlessPacket(). { char userinfo[MAX_INFO_STRING]; int i; client_t *cl, *newcl; MAC_STATIC client_t temp; sharedEntity_t *ent; int clientNum; int version; int qport; int challenge; char *password; int startIndex; char *denied; int count; Com_DPrintf ("SVC_DirectConnect ()\n"); Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) ); version = atoi( Info_ValueForKey( userinfo, "protocol" ) ); if ( version != PROTOCOL_VERSION ) { NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i.\n", PROTOCOL_VERSION ); Com_DPrintf (" rejected connect from version %i\n", version); return; } challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) ); qport = atoi( Info_ValueForKey( userinfo, "qport" ) ); // quick reject 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 ) && ( cl->netchan.qport == qport || from.port == cl->netchan.remoteAddress.port ) ) { if (( svs.time - cl->lastConnectTime) < (sv_reconnectlimit->integer * 1000)) { Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from)); return; } break; } } // see if the challenge is valid (LAN clients don't need to challenge) if ( !NET_IsLocalAddress (from) ) { int ping; for (i=0 ; i<MAX_CHALLENGES ; i++) { if (NET_CompareAdr(from, svs.challenges[i].adr)) { if ( challenge == svs.challenges[i].challenge ) { break; // good } } } if (i == MAX_CHALLENGES) { NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for address.\n" ); return; } // force the IP key/value pair so the game can filter based on ip Info_SetValueForKey( userinfo, "ip", NET_AdrToString( from ) ); ping = svs.time - svs.challenges[i].pingTime; Com_Printf( "Client %i connecting with %i challenge ping\n", i, ping ); svs.challenges[i].connected = qtrue; // never reject a LAN client based on ping if ( !Sys_IsLANAddress( from ) ) { if ( sv_minPing->value && ping < sv_minPing->value ) { // don't let them keep trying until they get a big delay NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for high pings only\n" ); Com_DPrintf ("Client %i rejected on a too low ping\n", i); // reset the address otherwise their ping will keep increasing // with each connect message and they'd eventually be able to connect svs.challenges[i].adr.port = 0; return; } if ( sv_maxPing->value && ping > sv_maxPing->value ) { NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is for low pings only\n" ); Com_DPrintf ("Client %i rejected on a too high ping\n", i); return; } } } else { // force the "ip" info key to "localhost" Info_SetValueForKey( userinfo, "ip", "localhost" ); } newcl = &temp; Com_Memset (newcl, 0, sizeof(client_t)); // if there is already a slot for this ip, reuse it 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 ) && ( cl->netchan.qport == qport || from.port == cl->netchan.remoteAddress.port ) ) { Com_Printf ("%s:reconnect\n", NET_AdrToString (from)); newcl = cl; // this doesn't work because it nukes the players userinfo // // disconnect the client from the game first so any flags the // // player might have are dropped // VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients ); // goto gotnewcl; } } // find a client slot // if "sv_privateClients" is set > 0, then that number // of client slots will be reserved for connections that // have "password" set to the value of "sv_privatePassword" // Info requests will report the maxclients as if the private // slots didn't exist, to prevent people from trying to connect // to a full server. // This is to allow us to reserve a couple slots here on our // servers so we can play without having to kick people. // check for privateClient password password = Info_ValueForKey( userinfo, "password" ); if ( !strcmp( password, sv_privatePassword->string ) ) { startIndex = 0; } else { // skip past the reserved slots startIndex = sv_privateClients->integer; } newcl = NULL; for ( i = startIndex; i < sv_maxclients->integer ; i++ ) { cl = &svs.clients[i]; if (cl->state == CS_FREE) { newcl = cl; break; } } if ( !newcl ) { if ( NET_IsLocalAddress( from ) ) { count = 0; for ( i = startIndex; i < sv_maxclients->integer ; i++ ) { cl = &svs.clients[i]; if (cl->netchan.remoteAddress.type == NA_BOT) { count++; } } // if they're all bots if (count >= sv_maxclients->integer - startIndex) { SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server"); newcl = &svs.clients[sv_maxclients->integer - 1]; } else { Com_Error( ERR_FATAL, "server is full on local connect\n" ); return; } } else { NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is full.\n" ); Com_DPrintf ("Rejected a connection.\n"); return; } } // we got a newcl, so reset the reliableSequence and reliableAcknowledge cl->reliableAcknowledge = 0; cl->reliableSequence = 0; gotnewcl: // build a new connection // accept the new client // this is the only place a client_t is ever initialized *newcl = temp; clientNum = newcl - svs.clients; ent = SV_GentityNum( clientNum ); newcl->gentity = ent; // save the challenge newcl->challenge = challenge; // save the address Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport); // init the netchan queue newcl->netchan_end_queue = &newcl->netchan_start_queue; // save the userinfo Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) ); // get the game a chance to reject this connection or modify the userinfo denied = (char *)VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue if ( denied ) { // we can't just use VM_ArgPtr, because that is only valid inside a VM_Call denied = VM_ExplicitArgPtr( gvm, (int)denied ); NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied ); Com_DPrintf ("Game rejected a connection: %s.\n", denied); return; } SV_UserinfoChanged( newcl ); // send the connect packet to the client NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" ); Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name ); newcl->state = CS_CONNECTED; newcl->nextSnapshotTime = svs.time; newcl->lastPacketTime = svs.time; newcl->lastConnectTime = svs.time; // when we receive the first packet from the client, we will // notice that it is from a different serverid and that the // gamestate message was not just sent, forcing a retransmit newcl->gamestateMessageNum = -1; // if this was the first client on the server, or the last client // the server can hold, send a heartbeat to the master. count = 0; for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) { if ( svs.clients[i].state >= CS_CONNECTED ) { count++; } } if ( count == 1 || count == sv_maxclients->integer ) { SV_Heartbeat_f(); } }

Here is the call graph for this function:

void SV_Disconnect_f (  client_t *  cl  )  [static]

Definition at line 930 of file sv_client.c. References cl, client_t, and SV_DropClient(). { SV_DropClient( cl, "disconnected" ); }

Here is the call graph for this function:

void SV_DoneDownload_f (  client_t *  cl  )

Definition at line 693 of file sv_client.c. References cl, client_t, Com_DPrintf(), and SV_SendClientGameState(). { Com_DPrintf( "clientDownload: %s Done\n", cl->name); // resend the game state to update any clients that entered during the download SV_SendClientGameState(cl); }

Here is the call graph for this function:

void SV_DropClient (  client_t *  drop, const char *  reason )

Definition at line 473 of file sv_client.c. References challenge_t::adr, serverStatic_t::challenges, client_t, serverStatic_t::clients, Com_DPrintf(), challenge_t::connected, client_s::download, FS_FCloseFile(), GAME_CLIENT_DISCONNECT, client_s::gentity, gvm, i, cvar_s::integer, client_s::name, NET_CompareAdr(), client_s::netchan, NULL, sharedEntity_t::r, netchan_t::remoteAddress, S_COLOR_WHITE, client_s::state, SV_BotFreeClient(), SV_CloseDownload(), SV_Heartbeat_f(), sv_maxclients, SV_SendServerCommand(), SV_SetUserinfo(), entityShared_t::svFlags, svs, netadr_t::type, and VM_Call(). Referenced by SV_AddServerCommand(), SV_CheckTimeouts(), SV_ClientCommand(), SV_DirectConnect(), SV_Disconnect_f(), SV_ExecuteClientMessage(), SV_GameDropClient(), SV_Kick_f(), SV_KickNum_f(), SV_MapRestart_f(), SV_NextDownload_f(), SV_SpawnServer(), SV_UserMove(), and SV_VerifyPaks_f(). { int i; challenge_t *challenge; if ( drop->state == CS_ZOMBIE ) { return; // already dropped } if ( !drop->gentity || !(drop->gentity->r.svFlags & SVF_BOT) ) { // see if we already have a challenge for this ip challenge = &svs.challenges[0]; for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++) { if ( NET_CompareAdr( drop->netchan.remoteAddress, challenge->adr ) ) { challenge->connected = qfalse; break; } } } // Kill any download SV_CloseDownload( drop ); // tell everyone why they got dropped SV_SendServerCommand( NULL, "print \"%s" S_COLOR_WHITE " %s\n\"", drop->name, reason ); Com_DPrintf( "Going to CS_ZOMBIE for %s\n", drop->name ); drop->state = CS_ZOMBIE; // become free in a few seconds if (drop->download) { FS_FCloseFile( drop->download ); drop->download = 0; } // call the prog function for removing a client // this will remove the body, among other things VM_Call( gvm, GAME_CLIENT_DISCONNECT, drop - svs.clients ); // add the disconnect command SV_SendServerCommand( drop, "disconnect \"%s\"", reason); if ( drop->netchan.remoteAddress.type == NA_BOT ) { SV_BotFreeClient( drop - svs.clients ); } // nuke user info SV_SetUserinfo( drop - svs.clients, "" ); // if this was the last client on the server, send a heartbeat // to the master so it is known the server is empty // send a heartbeat now so the master will get up to date info // if there is already a slot for this ip, reuse it for (i=0 ; i < sv_maxclients->integer ; i++ ) { if ( svs.clients[i].state >= CS_CONNECTED ) { break; } } if ( i == sv_maxclients->integer ) { SV_Heartbeat_f(); } }

Here is the call graph for this function:

void SV_ExecuteClientCommand (  client_t *  cl, const char *  s, qboolean  clientOK )

Definition at line 1219 of file sv_client.c. References cl, client_t, serverStatic_t::clients, Cmd_Argv(), Cmd_TokenizeString(), Com_DPrintf(), ucmd_t::func, GAME_CLIENT_COMMAND, gvm, ucmd_t::name, qboolean, s, server_t::state, strcmp(), sv, svs, and VM_Call(). Referenced by BotClientCommand(), and SV_ClientCommand(). { ucmd_t *u; qboolean bProcessed = qfalse; Cmd_TokenizeString( s ); // see if it is a server level command for (u=ucmds ; u->name ; u++) { if (!strcmp (Cmd_Argv(0), u->name) ) { u->func( cl ); bProcessed = qtrue; break; } } if (clientOK) { // pass unknown strings to the game if (!u->name && sv.state == SS_GAME) { VM_Call( gvm, GAME_CLIENT_COMMAND, cl - svs.clients ); } } else if (!bProcessed) Com_DPrintf( "client text ignored for %s: %s\n", cl->name, Cmd_Argv(0) ); }

Here is the call graph for this function:

void SV_ExecuteClientMessage (  client_t *  cl, msg_t *  msg )

Definition at line 1444 of file sv_client.c. References c, cl, client_t, serverStatic_t::clients, Com_DPrintf(), Com_Printf(), MSG_Bitstream(), MSG_ReadByte(), MSG_ReadLong(), qfalse, qtrue, server_t::restartedServerId, server_t::serverId, strstr(), sv, SV_ClientCommand(), SV_DropClient(), SV_SendClientGameState(), SV_UserMove(), and svs. Referenced by SV_PacketEvent(). { int c; int serverId; MSG_Bitstream(msg); serverId = MSG_ReadLong( msg ); cl->messageAcknowledge = MSG_ReadLong( msg ); if (cl->messageAcknowledge < 0) { // usually only hackers create messages like this // it is more annoying for them to let them hanging #ifndef NDEBUG SV_DropClient( cl, "DEBUG: illegible client message" ); #endif return; } cl->reliableAcknowledge = MSG_ReadLong( msg ); // NOTE: when the client message is fux0red the acknowledgement numbers // can be out of range, this could cause the server to send thousands of server // commands which the server thinks are not yet acknowledged in SV_UpdateServerCommandsToClient if (cl->reliableAcknowledge < cl->reliableSequence - MAX_RELIABLE_COMMANDS) { // usually only hackers create messages like this // it is more annoying for them to let them hanging #ifndef NDEBUG SV_DropClient( cl, "DEBUG: illegible client message" ); #endif cl->reliableAcknowledge = cl->reliableSequence; return; } // if this is a usercmd from a previous gamestate, // ignore it or retransmit the current gamestate // // if the client was downloading, let it stay at whatever serverId and // gamestate it was at. This allows it to keep downloading even when // the gamestate changes. After the download is finished, we'll // notice and send it a new game state // // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=536 // don't drop as long as previous command was a nextdl, after a dl is done, downloadName is set back to "" // but we still need to read the next message to move to next download or send gamestate // I don't like this hack though, it must have been working fine at some point, suspecting the fix is somewhere else if ( serverId != sv.serverId && !*cl->downloadName && !strstr(cl->lastClientCommandString, "nextdl") ) { if ( serverId >= sv.restartedServerId && serverId < sv.serverId ) { // TTimo - use a comparison here to catch multiple map_restart // they just haven't caught the map_restart yet Com_DPrintf("%s : ignoring pre map_restart / outdated client message\n", cl->name); return; } // if we can tell that the client has dropped the last // gamestate we sent them, resend it if ( cl->messageAcknowledge > cl->gamestateMessageNum ) { Com_DPrintf( "%s : dropped gamestate, resending\n", cl->name ); SV_SendClientGameState( cl ); } return; } // read optional clientCommand strings do { c = MSG_ReadByte( msg ); if ( c == clc_EOF ) { break; } if ( c != clc_clientCommand ) { break; } if ( !SV_ClientCommand( cl, msg ) ) { return; // we couldn't execute it because of the flood protection } if (cl->state == CS_ZOMBIE) { return; // disconnect command } } while ( 1 ); // read the usercmd_t if ( c == clc_move ) { SV_UserMove( cl, msg, qtrue ); } else if ( c == clc_moveNoDelta ) { SV_UserMove( cl, msg, qfalse ); } else if ( c != clc_EOF ) { Com_Printf( "WARNING: bad command byte for client %i\n", cl - svs.clients ); } // if ( msg->readcount != msg->cursize ) { // Com_Printf( "WARNING: Junk at end of packet for client %i\n", cl - svs.clients ); // } }

Here is the call graph for this function:

void SV_GetChallenge (  netadr_t  from  )

Definition at line 46 of file sv_client.c. References challenge_t::adr, AUTHORIZE_SERVER_NAME, serverStatic_t::authorizeAddress, BASEGAME, BigShort(), challenge_t::challenge, serverStatic_t::challenges, Com_DPrintf(), Com_Printf(), challenge_t::connected, Cvar_Get(), CVAR_INIT, CVAR_SYSTEMINFO, cvar_t, Cvar_VariableValue(), challenge_t::firstTime, GT_SINGLE_PLAYER, i, netadr_t::ip, NET_AdrToString(), NET_CompareAdr(), NET_OutOfBandPrint(), NET_StringToAdr(), NS_SERVER, challenge_t::pingTime, netadr_t::port, PORT_AUTHORIZE, rand(), strcpy(), cvar_s::string, sv_strictAuth, svs, Sys_IsLANAddress(), serverStatic_t::time, challenge_t::time, and netadr_t::type. Referenced by SV_ConnectionlessPacket(). { int i; int oldest; int oldestTime; challenge_t *challenge; // ignore if we are in single player if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER || Cvar_VariableValue("ui_singlePlayerActive")) { return; } oldest = 0; oldestTime = 0x7fffffff; // see if we already have a challenge for this ip challenge = &svs.challenges[0]; for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++) { if ( !challenge->connected && NET_CompareAdr( from, challenge->adr ) ) { break; } if ( challenge->time < oldestTime ) { oldestTime = challenge->time; oldest = i; } } if (i == MAX_CHALLENGES) { // this is the first time this client has asked for a challenge challenge = &svs.challenges[oldest]; challenge->challenge = ( (rand() << 16) ^ rand() ) ^ svs.time; challenge->adr = from; challenge->firstTime = svs.time; challenge->time = svs.time; challenge->connected = qfalse; i = oldest; } // if they are on a lan address, send the challengeResponse immediately if ( Sys_IsLANAddress( from ) ) { challenge->pingTime = svs.time; NET_OutOfBandPrint( NS_SERVER, from, "challengeResponse %i", challenge->challenge ); return; } // look up the authorize server's IP if ( !svs.authorizeAddress.ip[0] && svs.authorizeAddress.type != NA_BAD ) { Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME ); if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &svs.authorizeAddress ) ) { Com_Printf( "Couldn't resolve address\n" ); return; } svs.authorizeAddress.port = BigShort( PORT_AUTHORIZE ); Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME, svs.authorizeAddress.ip[0], svs.authorizeAddress.ip[1], svs.authorizeAddress.ip[2], svs.authorizeAddress.ip[3], BigShort( svs.authorizeAddress.port ) ); } // if they have been challenging for a long time and we // haven't heard anything from the authorize server, go ahead and // let them in, assuming the id server is down if ( svs.time - challenge->firstTime > AUTHORIZE_TIMEOUT ) { Com_DPrintf( "authorize server timed out\n" ); challenge->pingTime = svs.