/**
* @sa SV_Spawn_f
*/
static void SV_Begin_f (client_t *cl)
{
qboolean began;
Com_DPrintf(DEBUG_SERVER, "Begin() from %s\n", cl->name);
/* could be abused to respawn or cause spam/other mod-specific problems */
if (cl->state != cs_spawning) {
Com_Printf("EXPLOIT: Illegal 'begin' from %s (already spawned), client dropped.\n", cl->name);
SV_DropClient(cl, "Illegal begin\n");
return;
}
/* call the game begin function */
TH_MutexLock(svs.serverMutex);
began = svs.ge->ClientBegin(cl->player);
TH_MutexUnlock(svs.serverMutex);
if (!began) {
SV_DropClient(cl, "'begin' failed\n");
return;
}
SV_SetClientState(cl, cs_began);
Cbuf_InsertFromDefer();
}
/**
* @brief Called when the player is totally leaving the server, either willingly
* or unwillingly. This is NOT called if the entire server is quitting
* or crashing.
*/
void SV_DropClient (client_t * drop, const char *message)
{
/* add the disconnect */
dbuffer msg(2 + strlen(message));
NET_WriteByte(&msg, svc_disconnect);
NET_WriteString(&msg, message);
NET_WriteMsg(drop->stream, msg);
SV_BroadcastPrintf(PRINT_CHAT, "%s was dropped from the server - reason: %s\n", drop->name, message);
if (drop->state == cs_spawned || drop->state == cs_spawning) {
/* call the prog function for removing a client */
/* this will remove the body, among other things */
const ScopedMutex scopedMutex(svs.serverMutex);
svs.ge->ClientDisconnect(drop->player);
}
NET_StreamFinished(drop->stream);
drop->stream = NULL;
drop->player->inuse = false;
SV_SetClientState(drop, cs_free);
drop->name[0] = 0;
if (svs.abandon) {
int count = 0;
client_t *cl = NULL;
while ((cl = SV_GetNextClient(cl)) != NULL)
if (cl->state >= cs_connected)
count++;
if (count == 0)
svs.killserver = true;
}
}
/**
* @brief Change the server to a new map, taking all connected clients along with it.
* @note the full syntax is: @code map [day|night] [+]<map> [<assembly>] @endcode
* @sa SV_AssembleMap
* @sa CM_LoadMap
* @sa Com_SetServerState
*/
void SV_Map (qboolean day, const char *levelstring, const char *assembly)
{
int i;
unsigned checksum = 0;
char * map = SV_GetConfigString(CS_TILES);
char * pos = SV_GetConfigString(CS_POSITIONS);
mapInfo_t *randomMap = NULL;
client_t *cl;
/* any partially connected client will be restarted */
Com_SetServerState(ss_restart);
/* the game is just starting */
SV_InitGame();
if (!svs.initialized) {
Com_Printf("Could not spawn the server\n");
return;
}
assert(levelstring[0] != '\0');
Com_DPrintf(DEBUG_SERVER, "SpawnServer: %s\n", levelstring);
/* save name for levels that don't set message */
SV_SetConfigString(CS_NAME, levelstring);
SV_SetConfigString(CS_LIGHTMAP, day);
Q_strncpyz(sv->name, levelstring, sizeof(sv->name));
/* set serverinfo variable */
sv_mapname = Cvar_FullSet("sv_mapname", sv->name, CVAR_SERVERINFO | CVAR_NOSET);
/* notify the client in case of a listening server */
SCR_BeginLoadingPlaque();
if (assembly)
Q_strncpyz(sv->assembly, assembly, sizeof(sv->assembly));
else
sv->assembly[0] = '\0';
/* leave slots at start for clients only */
cl = NULL;
while ((cl = SV_GetNextClient(cl)) != NULL) {
/* needs to reconnect */
if (cl->state >= cs_spawning)
SV_SetClientState(cl, cs_connected);
}
/* assemble and load the map */
if (levelstring[0] == '+') {
randomMap = SV_AssembleMap(levelstring + 1, assembly, map, pos, 0);
if (!randomMap) {
Com_Printf("Could not load assembly for map '%s'\n", levelstring);
return;
}
} else {
SV_SetConfigString(CS_TILES, levelstring);
SV_SetConfigString(CS_POSITIONS, assembly ? assembly : "");
}
CM_LoadMap(map, day, pos, &sv->mapData, &sv->mapTiles);
Com_Printf("checksum for the map '%s': %u\n", levelstring, sv->mapData.mapChecksum);
SV_SetConfigString(CS_MAPCHECKSUM, sv->mapData.mapChecksum);
checksum = Com_GetScriptChecksum();
Com_Printf("ufo script checksum %u\n", checksum);
SV_SetConfigString(CS_UFOCHECKSUM, checksum);
SV_SetConfigString(CS_OBJECTAMOUNT, csi.numODs);
SV_SetConfigString(CS_VERSION, UFO_VERSION);
SV_SetConfigString(CS_MAPTITLE, SV_GetMapTitle(randomMap, levelstring));
if (Q_strstart(SV_GetConfigString(CS_MAPTITLE), "b/")) {
/* For base attack, CS_MAPTITLE contains too many chars */
SV_SetConfigString(CS_MAPTITLE, "Base attack");
SV_SetConfigString(CS_NAME, ".baseattack");
}
/* clear random-map assembly data */
Mem_Free(randomMap);
randomMap = NULL;
/* clear physics interaction links */
SV_ClearWorld();
/* fix this! */
for (i = 1; i <= sv->mapData.numInline; i++)
sv->models[i] = CM_InlineModel(&sv->mapTiles, va("*%i", i));
/* precache and static commands can be issued during map initialization */
Com_SetServerState(ss_loading);
TH_MutexLock(svs.serverMutex);
/* load and spawn all other entities */
svs.ge->SpawnEntities(sv->name, SV_GetConfigStringInteger(CS_LIGHTMAP), sv->mapData.mapEntityString);
TH_MutexUnlock(svs.serverMutex);
/* all precaches are complete */
Com_SetServerState(ss_game);
Com_Printf("-------------------------------------\n");
Cbuf_CopyToDefer();
}
/**
* @brief Sends the first message from the server to a connected client.
* This will be sent on the initial connection and upon each server load.
* Client reads via CL_ParseServerData in cl_parse.c
* @sa CL_Reconnect_f
* @sa CL_ConnectionlessPacket
*/
static void SV_New_f (client_t *cl)
{
Com_DPrintf(DEBUG_SERVER, "New() from %s\n", cl->name);
if (cl->state != cs_connected) {
if (cl->state == cs_spawning) {
/* client typed 'reconnect/new' while connecting. */
Com_Printf("SV_New_f: client typed 'reconnect/new' while connecting\n");
SV_ClientCommand(cl, "\ndisconnect\nreconnect\n");
SV_DropClient(cl, "");
} else
Com_DPrintf(DEBUG_SERVER, "WARNING: Illegal 'new' from %s, client state %d. This shouldn't happen...\n", cl->name, cl->state);
return;
}
/* client state to prevent multiple new from causing high cpu / overflows. */
SV_SetClientState(cl, cs_spawning);
/* serverdata needs to go over for all types of servers
* to make sure the protocol is right, and to set the gamedir */
/* send the serverdata */
{
const int playernum = cl - SV_GetClient(0);
struct dbuffer *msg = new_dbuffer();
NET_WriteByte(msg, svc_serverdata);
NET_WriteLong(msg, PROTOCOL_VERSION);
NET_WriteShort(msg, playernum);
/* send full levelname */
NET_WriteString(msg, SV_GetConfigString(CS_NAME));
NET_WriteMsg(cl->stream, msg);
}
/* game server */
if (Com_ServerState() == ss_game) {
int i;
for (i = 0; i < MAX_CONFIGSTRINGS; i++) {
const char *configString;
/* CS_TILES and CS_POSITIONS can stretch over multiple configstrings,
* so don't send the middle parts again. */
if (i > CS_TILES && i < CS_POSITIONS)
continue;
if (i > CS_POSITIONS && i < CS_MODELS)
continue;
configString = SV_GetConfigString(i);
if (configString[0] != '\0') {
struct dbuffer *msg = new_dbuffer();
Com_DPrintf(DEBUG_SERVER, "sending configstring %d: %s\n", i, configString);
NET_WriteByte(msg, svc_configstring);
NET_WriteShort(msg, i);
NET_WriteString(msg, configString);
/* enqueue and free msg */
NET_WriteMsg(cl->stream, msg);
}
}
}
SV_ClientCommand(cl, "precache\n");
}
/**
* @brief The current net_message is parsed for the given client
*/
void SV_ExecuteClientMessage (client_t * cl, int cmd, struct dbuffer *msg)
{
if (cmd == -1)
return;
switch (cmd) {
default:
Com_Printf("SV_ExecuteClientMessage: unknown command char '%d'\n", cmd);
SV_DropClient(cl, "Unknown command\n");
return;
case clc_nop:
break;
case clc_ack:
cl->lastmessage = svs.realtime;
break;
case clc_userinfo:
NET_ReadString(msg, cl->userinfo, sizeof(cl->userinfo));
Com_DPrintf(DEBUG_SERVER, "userinfo from client: %s\n", cl->userinfo);
SV_UserinfoChanged(cl);
break;
case clc_stringcmd:
{
char str[1024];
NET_ReadString(msg, str, sizeof(str));
Com_DPrintf(DEBUG_SERVER, "stringcmd from client: %s\n", str);
SV_ExecuteUserCommand(cl, str);
if (cl->state == cs_free)
return; /* disconnect command */
break;
}
case clc_action:
/* client actions are handled by the game module */
sv->messageBuffer = msg;
TH_MutexLock(svs.serverMutex);
svs.ge->ClientAction(cl->player);
TH_MutexUnlock(svs.serverMutex);
sv->messageBuffer = NULL;
break;
case clc_endround:
/* player wants to end round */
sv->messageBuffer = msg;
TH_MutexLock(svs.serverMutex);
svs.ge->ClientEndRound(cl->player);
TH_MutexUnlock(svs.serverMutex);
sv->messageBuffer = NULL;
break;
case clc_teaminfo:
/* player sends team info */
/* actors spawn accordingly */
sv->messageBuffer = msg;
TH_MutexLock(svs.serverMutex);
svs.ge->ClientTeamInfo(cl->player);
TH_MutexUnlock(svs.serverMutex);
sv->messageBuffer = NULL;
SV_SetClientState(cl, cs_spawned);
break;
case clc_initactorstates:
/* player sends team info */
/* actors spawn accordingly */
sv->messageBuffer = msg;
TH_MutexLock(svs.serverMutex);
svs.ge->ClientInitActorStates(cl->player);
TH_MutexUnlock(svs.serverMutex);
sv->messageBuffer = NULL;
break;
}
}
/**
* @brief A connection request that did not come from the master
* @sa CL_ConnectionlessPacket
*/
static void SVC_DirectConnect (struct net_stream *stream)
{
char userinfo[MAX_INFO_STRING];
client_t *cl;
player_t *player;
int playernum;
int version;
bool connected;
char buf[256];
const char *peername = NET_StreamPeerToName(stream, buf, sizeof(buf), false);
Com_DPrintf(DEBUG_SERVER, "SVC_DirectConnect()\n");
if (sv->started || sv->spawned) {
Com_Printf("rejected connect because match is already running\n");
NET_OOB_Printf(stream, "print\nGame has started already.\n");
return;
}
version = atoi(Cmd_Argv(1));
if (version != PROTOCOL_VERSION) {
Com_Printf("rejected connect from version %i - %s\n", version, peername);
NET_OOB_Printf(stream, "print\nServer is version %s.\n", UFO_VERSION);
return;
}
Q_strncpyz(userinfo, Cmd_Argv(2), sizeof(userinfo));
if (userinfo[0] == '\0') { /* catch empty userinfo */
Com_Printf("Empty userinfo from %s\n", peername);
NET_OOB_Printf(stream, "print\nConnection refused.\n");
return;
}
if (strchr(userinfo, '\xFF')) { /* catch end of message in string exploit */
Com_Printf("Illegal userinfo contained xFF from %s\n", peername);
NET_OOB_Printf(stream, "print\nConnection refused.\n");
return;
}
if (strlen(Info_ValueForKey(userinfo, "ip"))) { /* catch spoofed ips */
Com_Printf("Illegal userinfo contained ip from %s\n", peername);
NET_OOB_Printf(stream, "print\nConnection refused.\n");
return;
}
/* force the IP key/value pair so the game can filter based on ip */
Info_SetValueForKey(userinfo, sizeof(userinfo), "ip", peername);
/* find a client slot */
cl = NULL;
while ((cl = SV_GetNextClient(cl)) != NULL)
if (cl->state == cs_free)
break;
if (cl == NULL) {
NET_OOB_Printf(stream, "print\nServer is full.\n");
Com_Printf("Rejected a connection - server is full.\n");
return;
}
/* build a new connection - accept the new client
* this is the only place a client_t is ever initialized */
OBJZERO(*cl);
playernum = cl - SV_GetClient(0);
player = PLAYER_NUM(playernum);
cl->player = player;
cl->player->num = playernum;
{
const ScopedMutex scopedMutex(svs.serverMutex);
connected = svs.ge->ClientConnect(player, userinfo, sizeof(userinfo));
}
/* get the game a chance to reject this connection or modify the userinfo */
if (!connected) {
const char *rejmsg = Info_ValueForKey(userinfo, "rejmsg");
if (rejmsg[0] != '\0') {
NET_OOB_Printf(stream, "print\n%s\nConnection refused.\n", rejmsg);
Com_Printf("Game rejected a connection from %s. Reason: %s\n", peername, rejmsg);
} else {
NET_OOB_Printf(stream, "print\nConnection refused.\n");
Com_Printf("Game rejected a connection from %s.\n", peername);
}
return;
}
/* new player */
cl->player->inuse = true;
cl->lastmessage = svs.realtime;
/* parse some info from the info strings */
strncpy(cl->userinfo, userinfo, sizeof(cl->userinfo) - 1);
SV_UserinfoChanged(cl);
/* send the connect packet to the client */
if (sv_http_downloadserver->string[0])
NET_OOB_Printf(stream, "client_connect dlserver=%s", sv_http_downloadserver->string);
else
NET_OOB_Printf(stream, "client_connect");
SV_SetClientState(cl, cs_connected);
Q_strncpyz(cl->peername, peername, sizeof(cl->peername));
cl->stream = stream;
NET_StreamSetData(stream, cl);
}
