#include "server.h"

Functions
void	SV_ClientReset (client_t *client)

static void	set_frame_time (void)

static void	resolve_masters (void)

static void	override_entity_string (const char *server)

void	SV_SpawnServer (mapcmd_t *cmd)

qboolean	SV_ParseMapCmd (mapcmd_t *cmd)

void	SV_InitGame (unsigned mvd_spawn)

Variables
server_static_t	svs

server_t	sv

Function Documentation

◆ override_entity_string()

static void override_entity_string ( const char * server )

static

Definition at line 90 of file init.c.

 {
     char *path = map_override_path->string;
     char buffer[MAX_QPATH], *str;
     ssize_t len;
  
     if (!*path) {
         return;
     }
  
     len = Q_concat(buffer, sizeof(buffer), path, server, ".ent", NULL);
     if (len >= sizeof(buffer)) {
         len = Q_ERR_NAMETOOLONG;
         goto fail1;
     }
  
     len = SV_LoadFile(buffer, (void **)&str);
     if (!str) {
         if (len == Q_ERR_NOENT) {
             return;
         }
         goto fail1;
     }
  
     if (len > MAX_MAP_ENTSTRING) {
         len = Q_ERR_FBIG;
         goto fail2;
     }
  
     Com_Printf("Loaded entity string from %s\n", buffer);
     sv.entitystring = str;
     return;
  
 fail2:
     SV_FreeFile(str);
 fail1:
     Com_EPrintf("Couldn't load entity string from %s: %s\n",
                 buffer, Q_ErrorString(len));
 }

Referenced by SV_SpawnServer().

◆ resolve_masters()

static void resolve_masters ( void )

static

Definition at line 60 of file init.c.

 {
 #if !USE_CLIENT
     master_t *m;
     time_t now, delta;
  
     now = time(NULL);
     FOR_EACH_MASTER(m) {
         // re-resolve valid address after one day,
         // resolve invalid address after three hours
         delta = m->adr.port ? 24 * 60 * 60 : 3 * 60 * 60;
         if (now < m->last_resolved) {
             m->last_resolved = now;
             continue;
         }
         if (now - m->last_resolved < delta) {
             continue;
         }
         if (NET_StringToAdr(m->name, &m->adr, PORT_MASTER)) {
             Com_DPrintf("Master server at %s.\n", NET_AdrToString(&m->adr));
         } else {
             Com_WPrintf("Couldn't resolve master: %s\n", m->name);
             m->adr.port = 0;
         }
         m->last_resolved = now = time(NULL);
     }
 #endif
 }

Referenced by SV_SpawnServer().

◆ set_frame_time()

static void set_frame_time ( void )

static

Definition at line 40 of file init.c.

 {
 #if USE_FPS
     int framediv;
  
     if (g_features->integer & GMF_VARIABLE_FPS)
         framediv = sv_fps->integer / BASE_FRAMERATE;
     else
         framediv = 1;
  
     clamp(framediv, 1, MAX_FRAMEDIV);
  
     sv.framerate = framediv * BASE_FRAMERATE;
     sv.frametime = BASE_FRAMETIME / framediv;
     sv.framediv = framediv;
  
     Cvar_SetInteger(sv_fps, sv.framerate, FROM_CODE);
 #endif
 }

Referenced by SV_SpawnServer().

◆ SV_ClientReset()

void SV_ClientReset ( client_t * client )

Definition at line 24 of file init.c.

 {
     if (client->state < cs_connected) {
         return;
     }
  
     // any partially connected client will be restarted
     client->state = cs_connected;
     client->framenum = 1; // frame 0 can't be used
     client->lastframe = -1;
     client->frames_nodelta = 0;
     client->send_delta = 0;
     client->suppress_count = 0;
     memset(&client->lastcmd, 0, sizeof(client->lastcmd));
 }

Referenced by MVD_ChangeLevel(), MVD_SwitchChannel(), and SV_SpawnServer().

◆ SV_InitGame()

void SV_InitGame ( unsigned mvd_spawn )

Definition at line 361 of file init.c.

 {
     int     i, entnum;
     edict_t *ent;
     client_t *client;
  
     if (svs.initialized) {
         // cause any connected clients to reconnect
         SV_Shutdown("Server restarted\n", ERR_RECONNECT | mvd_spawn);
     } else {
         // make sure the client is down
         CL_Disconnect(ERR_RECONNECT);
         SCR_BeginLoadingPlaque();
  
         CM_FreeMap(&sv.cm);
         SV_FreeFile(sv.entitystring);
         memset(&sv, 0, sizeof(sv));
  
 #if USE_FPS
         // set up default frametime for main loop
         sv.frametime = BASE_FRAMETIME;
 #endif
     }
  
     // get any latched variable changes (maxclients, etc)
     Cvar_GetLatchedVars();
  
 #if !USE_CLIENT
     Cvar_Reset(sv_recycle);
 #endif
  
     if (mvd_spawn) {
         Cvar_Set("deathmatch", "1");
         Cvar_Set("coop", "0");
     } else {
         if (Cvar_VariableInteger("coop") &&
             Cvar_VariableInteger("deathmatch")) {
             Com_Printf("Deathmatch and Coop both set, disabling Coop\n");
             Cvar_Set("coop", "0");
         }
  
         // dedicated servers can't be single player and are usually DM
         // so unless they explicity set coop, force it to deathmatch
         if (COM_DEDICATED) {
             if (!Cvar_VariableInteger("coop"))
                 Cvar_Set("deathmatch", "1");
         }
     }
  
     // init clients
     if (Cvar_VariableInteger("deathmatch")) {
         if (sv_maxclients->integer <= 1) {
             Cvar_SetInteger(sv_maxclients, 8, FROM_CODE);
         } else if (sv_maxclients->integer > CLIENTNUM_RESERVED) {
             Cvar_SetInteger(sv_maxclients, CLIENTNUM_RESERVED, FROM_CODE);
         }
     } else if (Cvar_VariableInteger("coop")) {
         if (sv_maxclients->integer <= 1 || sv_maxclients->integer > 4)
             Cvar_Set("maxclients", "4");
     } else {    // non-deathmatch, non-coop is one player
         Cvar_FullSet("maxclients", "1", CVAR_SERVERINFO | CVAR_LATCH, FROM_CODE);
     }
  
     // enable networking
     if (sv_maxclients->integer > 1) {
         NET_Config(NET_SERVER);
     }
  
     svs.client_pool = SV_Mallocz(sizeof(client_t) * sv_maxclients->integer);
  
     svs.num_entities = sv_maxclients->integer * UPDATE_BACKUP * MAX_PACKET_ENTITIES;
     svs.entities = SV_Mallocz(sizeof(entity_packed_t) * svs.num_entities);
  
     // initialize MVD server
     if (!mvd_spawn) {
         SV_MvdInit();
     }
  
     Cvar_ClampInteger(sv_reserved_slots, 0, sv_maxclients->integer - 1);
  
 #if USE_ZLIB
     svs.z.zalloc = SV_zalloc;
     svs.z.zfree = SV_zfree;
     if (deflateInit2(&svs.z, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
                      -MAX_WBITS, 9, Z_DEFAULT_STRATEGY) != Z_OK) {
         Com_Error(ERR_FATAL, "%s: deflateInit2() failed", __func__);
     }
 #endif
  
     // init game
 #if USE_MVD_CLIENT
     if (mvd_spawn) {
         if (ge) {
             SV_ShutdownGameProgs();
         }
         ge = &mvd_ge;
         ge->Init();
     } else
 #endif
         SV_InitGameProgs();
  
     // send heartbeat very soon
     svs.last_heartbeat = -(HEARTBEAT_SECONDS - 5) * 1000;
  
     for (i = 0; i < sv_maxclients->integer; i++) {
         client = svs.client_pool + i;
         entnum = i + 1;
         ent = EDICT_NUM(entnum);
         ent->s.number = entnum;
         client->edict = ent;
         client->number = i;
     }
  
     AC_Connect(mvd_spawn);
  
     svs.initialized = qtrue;
 }

Referenced by MVD_ChangeLevel(), MVD_Spawn_f(), parse_hello(), read_server_file(), and SV_Map().

◆ SV_ParseMapCmd()

qboolean SV_ParseMapCmd ( mapcmd_t * cmd )

Definition at line 285 of file init.c.

 {
     char        expanded[MAX_QPATH];
     char        *s, *ch;
     qerror_t    ret;
     size_t      len;
  
     s = cmd->buffer;
  
     // skip the end-of-unit flag if necessary
     if (*s == '*') {
         s++;
         cmd->endofunit = qtrue;
     }
  
     // if there is a + in the map, set nextserver to the remainder.
     ch = strchr(s, '+');
     if (ch)
     {
         *ch = 0;
         Cvar_Set("nextserver", va("gamemap \"%s\"", ch + 1));
     }
     else
         Cvar_Set("nextserver", "");
  
     cmd->server = s;
  
     // if there is a $, use the remainder as a spawnpoint
     ch = strchr(s, '$');
     if (ch) {
         *ch = 0;
         cmd->spawnpoint = ch + 1;
     } else {
         cmd->spawnpoint = cmd->buffer + strlen(cmd->buffer);
     }
  
     // now expand and try to load the map
     if (!COM_CompareExtension(s, ".pcx")) {
         len = Q_concat(expanded, sizeof(expanded), "pics/", s, NULL);
         if (len >= sizeof(expanded)) {
             ret = Q_ERR_NAMETOOLONG;
         } else {
             ret = FS_LoadFile(expanded, NULL);
         }
         cmd->state = ss_pic;
     } 
     else if (!COM_CompareExtension(s, ".cin")) {
         ret = Q_ERR_SUCCESS;
         cmd->state = ss_cinematic;
     }
     else {
         len = Q_concat(expanded, sizeof(expanded), "maps/", s, ".bsp", NULL);
         if (len >= sizeof(expanded)) {
             ret = Q_ERR_NAMETOOLONG;
         } else {
             ret = CM_LoadMap(&cmd->cm, expanded);
         }
         cmd->state = ss_game;
     }
  
     if (ret < 0) {
         Com_Printf("Couldn't load %s: %s\n", expanded, Q_ErrorString(ret));
         return qfalse;
     }
  
     return qtrue;
 }

Referenced by read_server_file(), and SV_Map().

◆ SV_SpawnServer()

void SV_SpawnServer ( mapcmd_t * cmd )

Definition at line 139 of file init.c.

 {
     int         i;
     client_t    *client;
     char        *entitystring;
  
     SCR_BeginLoadingPlaque();           // for local system
  
     Com_Printf("------- Server Initialization -------\n");
     Com_Printf("SpawnServer: %s\n", cmd->server);
  
     static qboolean warning_printed = qfalse;
     if (dedicated->integer && !SV_NoSaveGames() && !warning_printed)
     {
         Com_Printf("\nWARNING: Dedicated coop servers save game state into the same place as single player game by default (currently '%s/%s'). "
             "To override that, set the 'sv_savedir' console variable. To host multiple dedicated coop servers on one machine, set that cvar "
             "to different values on different instances of the server.\n\n", fs_gamedir, Cvar_WeakGet("sv_savedir")->string);
  
         warning_printed = qtrue;
     }
  
     // everyone needs to reconnect
     FOR_EACH_CLIENT(client) {
         SV_ClientReset(client);
     }
  
     SV_BroadcastCommand("changing map=%s\n", cmd->server);
     SV_SendClientMessages();
     SV_SendAsyncPackets();
  
     // free current level
     CM_FreeMap(&sv.cm);
     SV_FreeFile(sv.entitystring);
  
     // wipe the entire per-level structure
     memset(&sv, 0, sizeof(sv));
     sv.spawncount = (rand() | (rand() << 16)) ^ Sys_Milliseconds();
     sv.spawncount &= 0x7FFFFFFF;
  
     // set legacy spawncounts
     FOR_EACH_CLIENT(client) {
         client->spawncount = sv.spawncount;
     }
  
     // reset entity counter
     svs.next_entity = 0;
  
     // set framerate parameters
     set_frame_time();
  
     // save name for levels that don't set message
     Q_strlcpy(sv.configstrings[CS_NAME], cmd->server, MAX_QPATH);
     Q_strlcpy(sv.name, cmd->server, sizeof(sv.name));
     Q_strlcpy(sv.mapcmd, cmd->buffer, sizeof(sv.mapcmd));
  
     if (Cvar_VariableInteger("deathmatch")) {
         sprintf(sv.configstrings[CS_AIRACCEL], "%d", sv_airaccelerate->integer);
     } else {
         strcpy(sv.configstrings[CS_AIRACCEL], "0");
     }
  
     resolve_masters();
  
     if (cmd->state == ss_game) {
         override_entity_string(cmd->server);
  
         sv.cm = cmd->cm;
         sprintf(sv.configstrings[CS_MAPCHECKSUM], "%d", (int)sv.cm.cache->checksum);
  
         // set inline model names
         Q_concat(sv.configstrings[CS_MODELS + 1], MAX_QPATH, "maps/", cmd->server, ".bsp", NULL);
         for (i = 1; i < sv.cm.cache->nummodels; i++) {
             sprintf(sv.configstrings[CS_MODELS + 1 + i], "*%d", i);
         }
  
         entitystring = sv.entitystring ? sv.entitystring : sv.cm.cache->entitystring;
     } else {
         // no real map
         strcpy(sv.configstrings[CS_MAPCHECKSUM], "0");
         entitystring = "";
     }
  
     //
     // clear physics interaction links
     //
     SV_ClearWorld();
  
     //
     // spawn the rest of the entities on the map
     //
  
     // precache and static commands can be issued during
     // map initialization
     sv.state = ss_loading;
  
     X86_PUSH_FPCW;
     X86_SINGLE_FPCW;
  
     // load and spawn all other entities
     ge->SpawnEntities(sv.name, entitystring, cmd->spawnpoint);
  
     // run two frames to allow everything to settle
     ge->RunFrame(); sv.framenum++;
     ge->RunFrame(); sv.framenum++;
  
     X86_POP_FPCW;
  
     // make sure maxclients string is correct
     sprintf(sv.configstrings[CS_MAXCLIENTS], "%d", sv_maxclients->integer);
  
     // check for a savegame
     SV_CheckForSavegame(cmd);
  
     // all precaches are complete
     sv.state = cmd->state;
  
     // respawn dummy MVD client, set base states, etc
     SV_MvdMapChanged();
  
     // set serverinfo variable
     SV_InfoSet("mapname", sv.name);
     SV_InfoSet("port", net_port->string);
  
     Cvar_SetInteger(sv_running, sv.state, FROM_CODE);
     Cvar_Set("sv_paused", "0");
     Cvar_Set("timedemo", "0");
  
     EXEC_TRIGGER(sv_changemapcmd);
  
 #if USE_SYSCON
     SV_SetConsoleTitle();
 #endif
  
     SV_BroadcastCommand("reconnect\n");
  
     Com_Printf("-------------------------------------\n");
 }