user.c File Reference

#include "server.h"

Go to the source code of this file.

Functions
static void	create_baselines (void)
static void	write_plain_configstrings (void)
static void	write_baseline (entity_packed_t *base)
static void	write_plain_baselines (void)
static void	stuff_cmds (list_t *list)
static void	stuff_junk (void)
void	SV_New_f (void)
void	SV_Begin_f (void)
void	SV_CloseDownload (client_t *client)
static void	SV_NextDownload_f (void)
static void	SV_BeginDownload_f (void)
static void	SV_StopDownload_f (void)
static void	SV_NextServer_f (void)
static void	SV_Disconnect_f (void)
static void	SV_ShowServerInfo_f (void)
static void	SV_ShowMiscInfo_f (void)
static void	SV_NoGameData_f (void)
static void	SV_Lag_f (void)
static void	SV_CvarResult_f (void)
static void	SV_AC_List_f (void)
static void	SV_AC_Info_f (void)
static void	handle_filtercmd (filtercmd_t *filter)
static void	SV_ExecuteUserCommand (const char *s)
static void	SV_ClientThink (usercmd_t *cmd)
static void	SV_SetLastFrame (int lastframe)
static void	SV_OldClientExecuteMove (void)
static void	SV_NewClientExecuteMove (int c)
static void	SV_UpdateUserinfo (void)
static void	SV_ParseFullUserinfo (void)
static void	SV_ParseDeltaUserinfo (void)
static void	SV_ParseClientSetting (void)
static void	SV_ParseClientCommand (void)
void	SV_ExecuteClientMessage (client_t *client)

Variables
static const ucmd_t	ucmds []
static qboolean	moveIssued
static int	stringCmdCount
static int	userinfoUpdateCount

Function Documentation

create_baselines()

static void create_baselines ( void  )

static

Definition at line 40 of file user.c.

{
    int        i;
    edict_t    *ent;
    entity_packed_t *base, **chunk;
 
    // clear baselines from previous level
    for (i = 0; i < SV_BASELINES_CHUNKS; i++) {
        base = sv_client->baselines[i];
        if (!base) {
            continue;
        }
        memset(base, 0, sizeof(*base) * SV_BASELINES_PER_CHUNK);
    }
 
    for (i = 1; i < sv_client->pool->num_edicts; i++) {
        ent = EDICT_POOL(sv_client, i);
 
        if ((g_features->integer & GMF_PROPERINUSE) && !ent->inuse) {
            continue;
        }
 
        if (!ES_INUSE(&ent->s)) {
            continue;
        }
 
        ent->s.number = i;
 
        chunk = &sv_client->baselines[i >> SV_BASELINES_SHIFT];
        if (*chunk == NULL) {
            *chunk = SV_Mallocz(sizeof(*base) * SV_BASELINES_PER_CHUNK);
        }
 
        base = *chunk + (i & SV_BASELINES_MASK);
        MSG_PackEntity(base, &ent->s, Q2PRO_SHORTANGLES(sv_client, i));
 
#if USE_MVD_CLIENT
        if (sv.state == ss_broadcast) {
            // spectators only need to know about inline BSP models
            if (base->solid != PACKED_BSP)
                base->solid = 0;
        } else
#endif
        if (sv_client->esFlags & MSG_ES_LONGSOLID) {
            base->solid = sv.entities[i].solid32;
        }
    }
}

Referenced by SV_New_f().

handle_filtercmd()

static void handle_filtercmd ( filtercmd_t *  filter )

static

Definition at line 949 of file user.c.

{
    size_t len;
 
    switch (filter->action) {
    case FA_PRINT:
        MSG_WriteByte(svc_print);
        MSG_WriteByte(PRINT_HIGH);
        break;
    case FA_STUFF:
        MSG_WriteByte(svc_stufftext);
        break;
    case FA_KICK:
        SV_DropClient(sv_client, filter->comment[0] ?
                      filter->comment : "issued banned command");
        // fall through
    default:
        return;
    }
 
    len = strlen(filter->comment);
    MSG_WriteData(filter->comment, len);
    MSG_WriteByte('\n');
    MSG_WriteByte(0);
 
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by SV_ExecuteUserCommand().

stuff_cmds()

static void stuff_cmds ( list_t *  list )

static

Definition at line 308 of file user.c.

{
    stuffcmd_t *stuff;
 
    LIST_FOR_EACH(stuffcmd_t, stuff, list, entry) {
        MSG_WriteByte(svc_stufftext);
        MSG_WriteData(stuff->string, stuff->len);
        MSG_WriteByte('\n');
        MSG_WriteByte(0);
        SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
    }
}

Referenced by SV_Begin_f(), and SV_New_f().

stuff_junk()

static void stuff_junk ( void  )

static

Definition at line 321 of file user.c.

{
    static const char junkchars[] =
        "!~#``&'()*`+,-./~01~2`3`4~5`67`89:~<=`>?@~ab~c"
        "d`ef~j~k~lm`no~pq`rst`uv`w``x`yz[`\\]^_`|~";
    char junk[8][16];
    int i, j, k;
 
    for (i = 0; i < 8; i++) {
        for (j = 0; j < 15; j++) {
            k = rand_byte() % (sizeof(junkchars) - 1);
            junk[i][j] = junkchars[k];
        }
        junk[i][15] = 0;
    }
 
    strcpy(sv_client->reconnect_var, junk[2]);
    strcpy(sv_client->reconnect_val, junk[3]);
 
    SV_ClientCommand(sv_client, "set %s set\n", junk[0]);
    SV_ClientCommand(sv_client, "$%s %s connect\n", junk[0], junk[1]);
    if (rand_byte() & 1) {
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[2], junk[3]);
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[4],
                         sv_force_reconnect->string);
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[5], junk[6]);
    } else {
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[4],
                         sv_force_reconnect->string);
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[5], junk[6]);
        SV_ClientCommand(sv_client, "$%s %s %s\n", junk[0], junk[2], junk[3]);
    }
    SV_ClientCommand(sv_client, "$%s %s \"\"\n", junk[0], junk[0]);
    SV_ClientCommand(sv_client, "$%s $%s\n", junk[1], junk[4]);
}

Referenced by SV_New_f().

SV_AC_Info_f()

static void SV_AC_Info_f ( void  )

static

Definition at line 913 of file user.c.

{
    SV_ClientRedirect();
    AC_Info_f();
    Com_EndRedirect();
}

SV_AC_List_f()

static void SV_AC_List_f ( void  )

static

Definition at line 906 of file user.c.

{
    SV_ClientRedirect();
    AC_List_f();
    Com_EndRedirect();
}

SV_Begin_f()

void SV_Begin_f

(

void

)

Definition at line 488 of file user.c.

{
    Com_DPrintf("Begin() from %s\n", sv_client->name);
 
    // handle the case of a level changing while a client was connecting
    if (sv_client->state < cs_primed) {
        Com_DPrintf("Begin not valid -- not yet primed\n");
        SV_New_f();
        return;
    }
    if (sv_client->state > cs_primed) {
        Com_DPrintf("Begin not valid -- already spawned\n");
        return;
    }
 
    if (!sv_client->version_string) {
        SV_DropClient(sv_client, "!failed version probe");
        return;
    }
 
    if (sv_force_reconnect->string[0] && !sv_client->reconnected) {
        SV_DropClient(sv_client, "!failed to reconnect");
        return;
    }
 
    if (!AC_ClientBegin(sv_client)) {
        return;
    }
 
    Com_DPrintf("Going from cs_primed to cs_spawned for %s\n",
                sv_client->name);
    sv_client->state = cs_spawned;
    sv_client->send_delta = 0;
    sv_client->command_msec = 1800;
    sv_client->suppress_count = 0;
    sv_client->http_download = qfalse;
 
    SV_AlignKeyFrames(sv_client);
 
    stuff_cmds(&sv_cmdlist_begin);
 
    // call the game begin function
    ge->ClientBegin(sv_player);
 
    AC_ClientAnnounce(sv_client);
 
    // The server needs to complete the autosave after the client has connected.
    // See SV_Map (commands.c) for more information.
    if (sv_pending_autosave)
    {
        SV_AutoSaveEnd();
        sv_pending_autosave = qfalse;
    }
}

Referenced by AC_CheckTimeouts(), and AC_ParseQueryReply().

SV_BeginDownload_f()

static void SV_BeginDownload_f ( void  )

static

Definition at line 579 of file user.c.

{
    char    name[MAX_QPATH];
    byte    *download;
    int     downloadcmd;
    ssize_t downloadsize, maxdownloadsize, result;
    int     offset = 0;
    cvar_t  *allow;
    size_t  len;
    qhandle_t f;
 
    len = Cmd_ArgvBuffer(1, name, sizeof(name));
    if (len >= MAX_QPATH) {
        goto fail1;
    }
 
    // hack for 'status' command
    if (!strcmp(name, "http")) {
        sv_client->http_download = qtrue;
        return;
    }
 
    len = FS_NormalizePath(name, name);
 
    if (Cmd_Argc() > 2)
        offset = atoi(Cmd_Argv(2));     // downloaded offset
 
    // hacked by zoid to allow more conrol over download
    // first off, no .. or global allow check
    if (!allow_download->integer
        // check for empty paths
        || !len
        // check for illegal negative offsets
        || offset < 0
        // don't allow anything with .. path
        || strstr(name, "..")
        // leading dots, slashes, etc are no good
        || !Q_ispath(name[0])
        // trailing dots, slashes, etc are no good
        || !Q_ispath(name[len - 1])
        // MUST be in a subdirectory
        || !strchr(name, '/')) {
        Com_DPrintf("Refusing download of %s to %s\n", name, sv_client->name);
        goto fail1;
    }
 
    if (FS_pathcmpn(name, CONST_STR_LEN("players/")) == 0) {
        allow = allow_download_players;
    } else if (FS_pathcmpn(name, CONST_STR_LEN("models/")) == 0 ||
               FS_pathcmpn(name, CONST_STR_LEN("sprites/")) == 0) {
        allow = allow_download_models;
    } else if (FS_pathcmpn(name, CONST_STR_LEN("sound/")) == 0) {
        allow = allow_download_sounds;
    } else if (FS_pathcmpn(name, CONST_STR_LEN("maps/")) == 0) {
        allow = allow_download_maps;
    } else if (FS_pathcmpn(name, CONST_STR_LEN("textures/")) == 0 ||
               FS_pathcmpn(name, CONST_STR_LEN("env/")) == 0) {
        allow = allow_download_textures;
    } else if (FS_pathcmpn(name, CONST_STR_LEN("pics/")) == 0) {
        allow = allow_download_pics;
    } else {
        allow = allow_download_others;
    }
 
    if (!allow->integer) {
        Com_DPrintf("Refusing download of %s to %s\n", name, sv_client->name);
        goto fail1;
    }
 
    if (sv_client->download) {
        Com_DPrintf("Closing existing download for %s (should not happen)\n", sv_client->name);
        SV_CloseDownload(sv_client);
    }
 
    f = 0;
    downloadcmd = svc_download;
 
#if USE_ZLIB
    // prefer raw deflate stream from .pkz if supported
    if (sv_client->protocol == PROTOCOL_VERSION_Q2PRO &&
        sv_client->version >= PROTOCOL_VERSION_Q2PRO_ZLIB_DOWNLOADS &&
        sv_client->has_zlib && offset == 0) {
        downloadsize = FS_FOpenFile(name, &f, FS_MODE_READ | FS_FLAG_DEFLATE);
        if (f) {
            Com_DPrintf("Serving compressed download to %s\n", sv_client->name);
            downloadcmd = svc_zdownload;
        }
    }
#endif
 
    if (!f) {
        downloadsize = FS_FOpenFile(name, &f, FS_MODE_READ);
        if (!f) {
            Com_DPrintf("Couldn't download %s to %s\n", name, sv_client->name);
            goto fail1;
        }
    }
 
    maxdownloadsize = MAX_LOADFILE;
#if 0
    if (sv_max_download_size->integer) {
        maxdownloadsize = Cvar_ClampInteger(sv_max_download_size, 1, MAX_LOADFILE);
    }
#endif
 
    if (downloadsize == 0) {
        Com_DPrintf("Refusing empty download of %s to %s\n", name, sv_client->name);
        goto fail2;
    }
 
    if (downloadsize > maxdownloadsize) {
        Com_DPrintf("Refusing oversize download of %s to %s\n", name, sv_client->name);
        goto fail2;
    }
 
    if (offset > downloadsize) {
        Com_DPrintf("Refusing download, %s has wrong version of %s (%d > %d)\n",
                    sv_client->name, name, offset, (int)downloadsize);
        SV_ClientPrintf(sv_client, PRINT_HIGH, "File size differs from server.\n"
                        "Please delete the corresponding .tmp file from your system.\n");
        goto fail2;
    }
 
    if (offset == downloadsize) {
        Com_DPrintf("Refusing download, %s already has %s (%d bytes)\n",
                    sv_client->name, name, offset);
        FS_FCloseFile(f);
        MSG_WriteByte(svc_download);
        MSG_WriteShort(0);
        MSG_WriteByte(100);
        SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
        return;
    }
 
    download = SV_Malloc(downloadsize);
    result = FS_Read(download, downloadsize, f);
    if (result != downloadsize) {
        Com_DPrintf("Couldn't download %s to %s\n", name, sv_client->name);
        goto fail3;
    }
 
    FS_FCloseFile(f);
 
    sv_client->download = download;
    sv_client->downloadsize = downloadsize;
    sv_client->downloadcount = offset;
    sv_client->downloadname = SV_CopyString(name);
    sv_client->downloadcmd = downloadcmd;
    sv_client->downloadpending = qtrue;
 
    Com_DPrintf("Downloading %s to %s\n", name, sv_client->name);
    return;
 
fail3:
    Z_Free(download);
fail2:
    FS_FCloseFile(f);
fail1:
    MSG_WriteByte(svc_download);
    MSG_WriteShort(-1);
    MSG_WriteByte(0);
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
}

SV_ClientThink()

static void SV_ClientThink ( usercmd_t *  cmd )

inlinestatic

Definition at line 1043 of file user.c.

{
    usercmd_t *old = &sv_client->lastcmd;
 
    sv_client->command_msec -= cmd->msec;
    sv_client->num_moves++;
 
    if (sv_client->command_msec < 0 && sv_enforcetime->integer) {
        Com_DPrintf("commandMsec underflow from %s: %d\n",
                    sv_client->name, sv_client->command_msec);
        return;
    }
 
    if (cmd->buttons != old->buttons
        || cmd->forwardmove != old->forwardmove
        || cmd->sidemove != old->sidemove
        || cmd->upmove != old->upmove) {
        // don't timeout
        sv_client->lastactivity = svs.realtime;
    }
 
    ge->ClientThink(sv_player, cmd);
}

Referenced by SV_NewClientExecuteMove(), and SV_OldClientExecuteMove().

SV_CloseDownload()

void SV_CloseDownload

(

client_t *

client

)

Definition at line 545 of file user.c.

{
    if (client->download) {
        Z_Free(client->download);
        client->download = NULL;
    }
    if (client->downloadname) {
        Z_Free(client->downloadname);
        client->downloadname = NULL;
    }
    client->downloadsize = 0;
    client->downloadcount = 0;
    client->downloadcmd = 0;
    client->downloadpending = qfalse;
}

Referenced by SV_BeginDownload_f(), SV_CleanClient(), SV_StopDownload_f(), and write_pending_download().

SV_CvarResult_f()

static void SV_CvarResult_f ( void  )

static

Definition at line 874 of file user.c.

{
    char *c, *v;
 
    c = Cmd_Argv(1);
    if (!strcmp(c, "version")) {
        if (!sv_client->version_string) {
            v = Cmd_RawArgsFrom(2);
            if (COM_DEDICATED) {
                Com_Printf("%s[%s]: %s\n", sv_client->name,
                           NET_AdrToString(&sv_client->netchan->remote_address), v);
            }
            sv_client->version_string = SV_CopyString(v);
        }
    } else if (!strcmp(c, "connect")) {
        if (sv_client->reconnect_var[0]) {
            if (!strcmp(Cmd_Argv(2), sv_client->reconnect_val)) {
                sv_client->reconnected = qtrue;
            }
        }
    } else if (!strcmp(c, "actoken")) {
        AC_ClientToken(sv_client, Cmd_Argv(2));
    } else if (!strcmp(c, "console")) {
        if (sv_client->console_queries > 0) {
            Com_Printf("%s[%s]: \"%s\" is \"%s\"\n", sv_client->name,
                       NET_AdrToString(&sv_client->netchan->remote_address),
                       Cmd_Argv(2), Cmd_RawArgsFrom(3));
            sv_client->console_queries--;
        }
    }
}

SV_Disconnect_f()

static void SV_Disconnect_f ( void  )

static

Definition at line 796 of file user.c.

{
    SV_DropClient(sv_client, "!?disconnected");
    SV_RemoveClient(sv_client);   // don't bother with zombie state
}

SV_ExecuteClientMessage()

void SV_ExecuteClientMessage

(

client_t *

client

)

Definition at line 1482 of file user.c.

{
    int c;
 
    X86_PUSH_FPCW;
    X86_SINGLE_FPCW;
 
    sv_client = client;
    sv_player = sv_client->edict;
 
    // only allow one move command
    moveIssued = qfalse;
    stringCmdCount = 0;
    userinfoUpdateCount = 0;
 
    while (1) {
        if (msg_read.readcount > msg_read.cursize) {
            SV_DropClient(client, "read past end of message");
            break;
        }
 
        c = MSG_ReadByte();
        if (c == -1)
            break;
 
        switch (c & SVCMD_MASK) {
        default:
badbyte:
            SV_DropClient(client, "unknown command byte");
            break;
 
        case clc_nop:
            break;
 
        case clc_userinfo:
            SV_ParseFullUserinfo();
            break;
 
        case clc_move:
            SV_OldClientExecuteMove();
            break;
 
        case clc_stringcmd:
            SV_ParseClientCommand();
            break;
 
        case clc_setting:
            if (client->protocol < PROTOCOL_VERSION_R1Q2)
                goto badbyte;
 
            SV_ParseClientSetting();
            break;
 
        case clc_move_nodelta:
        case clc_move_batched:
            if (client->protocol != PROTOCOL_VERSION_Q2PRO)
                goto badbyte;
 
            SV_NewClientExecuteMove(c);
            break;
 
        case clc_userinfo_delta:
            if (client->protocol != PROTOCOL_VERSION_Q2PRO)
                goto badbyte;
 
            SV_ParseDeltaUserinfo();
            break;
        }
 
        if (client->state <= cs_zombie)
            break;    // disconnect command
    }
 
    sv_client = NULL;
    sv_player = NULL;
 
    X86_POP_FPCW;
}

Referenced by SV_PacketEvent().

SV_ExecuteUserCommand()

static void SV_ExecuteUserCommand ( const char *  s )

static

Definition at line 982 of file user.c.

{
    const ucmd_t *u;
    filtercmd_t *filter;
    char *c;
 
    Cmd_TokenizeString(s, qfalse);
    sv_player = sv_client->edict;
 
    c = Cmd_Argv(0);
    if (!c[0]) {
        return;
    }
 
    if ((u = Com_Find(ucmds, c)) != NULL) {
        if (u->func) {
            u->func();
        }
        return;
    }
 
    if (sv.state == ss_pic || sv.state == ss_cinematic) {
        return;
    }
 
    if (sv_client->state != cs_spawned && !sv_allow_unconnected_cmds->integer) {
        return;
    }
 
    LIST_FOR_EACH(filtercmd_t, filter, &sv_filterlist, entry) {
        if (!Q_stricmp(filter->string, c)) {
            handle_filtercmd(filter);
            return;
        }
    }
 
    if (!strcmp(c, "say") || !strcmp(c, "say_team")) {
        // don't timeout. only chat commands count as activity.
        sv_client->lastactivity = svs.realtime;
    }
 
    ge->ClientCommand(sv_player);
}

Referenced by SV_ParseClientCommand().

SV_Lag_f()

static void SV_Lag_f ( void  )

static

Definition at line 828 of file user.c.

{
    client_t *cl;
 
    if (Cmd_Argc() > 1) {
        SV_ClientRedirect();
        cl = SV_GetPlayer(Cmd_Argv(1), qtrue);
        Com_EndRedirect();
        if (!cl) {
            return;
        }
    } else {
        cl = sv_client;
    }
 
    SV_ClientPrintf(sv_client, PRINT_HIGH,
                    "Lag stats for:       %s\n"
                    "RTT (min/avg/max):   %d/%d/%d ms\n"
                    "Server to client PL: %.2f%% (approx)\n"
                    "Client to server PL: %.2f%%\n",
                    cl->name, cl->min_ping, AVG_PING(cl), cl->max_ping,
                    PL_S2C(cl), PL_C2S(cl));
}

SV_New_f()

void SV_New_f

(

void

)

Definition at line 365 of file user.c.

{
    clstate_t oldstate;
 
    Com_DPrintf("New() from %s\n", sv_client->name);
 
    oldstate = sv_client->state;
    if (sv_client->state < cs_connected) {
        Com_DPrintf("Going from cs_assigned to cs_connected for %s\n",
                    sv_client->name);
        sv_client->state = cs_connected;
        sv_client->lastmessage = svs.realtime; // don't timeout
        time(&sv_client->connect_time);
    } else if (sv_client->state > cs_connected) {
        Com_DPrintf("New not valid -- already primed\n");
        return;
    }
 
    // stuff some junk, drop them and expect them to be back soon
    if (sv_force_reconnect->string[0] && !sv_client->reconnect_var[0] &&
        !NET_IsLocalAddress(&sv_client->netchan->remote_address)) {
        stuff_junk();
        SV_DropClient(sv_client, NULL);
        return;
    }
 
    SV_ClientCommand(sv_client, "\n");
 
    //
    // serverdata needs to go over for all types of servers
    // to make sure the protocol is right, and to set the gamedir
    //
 
    // create baselines for this client
    create_baselines();
 
    // send the serverdata
    MSG_WriteByte(svc_serverdata);
    MSG_WriteLong(sv_client->protocol);
    MSG_WriteLong(sv_client->spawncount);
    MSG_WriteByte(0);   // no attract loop
    MSG_WriteString(sv_client->gamedir);
    if (sv.state == ss_pic || sv.state == ss_cinematic)
        MSG_WriteShort(-1);
    else
        MSG_WriteShort(sv_client->slot);
    MSG_WriteString(&sv_client->configstrings[CS_NAME * MAX_QPATH]);
 
    // send protocol specific stuff
    switch (sv_client->protocol) {
    case PROTOCOL_VERSION_R1Q2:
        MSG_WriteByte(0);   // not enhanced
        MSG_WriteShort(sv_client->version);
        MSG_WriteByte(0);   // no advanced deltas
        MSG_WriteByte(sv_client->pmp.strafehack);
        break;
    case PROTOCOL_VERSION_Q2PRO:
        MSG_WriteShort(sv_client->version);
        MSG_WriteByte(sv.state);
        MSG_WriteByte(sv_client->pmp.strafehack);
        MSG_WriteByte(sv_client->pmp.qwmode);
        if (sv_client->version >= PROTOCOL_VERSION_Q2PRO_WATERJUMP_HACK) {
            MSG_WriteByte(sv_client->pmp.waterhack);
        }
        break;
    default:
        break;
    }
 
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
 
    SV_ClientCommand(sv_client, "\n");
 
    // send version string request
    if (oldstate == cs_assigned) {
        SV_ClientCommand(sv_client, "cmd \177c version $version\n"
#if USE_AC_SERVER
                         "cmd \177c actoken $actoken\n"
#endif
                        );
        stuff_cmds(&sv_cmdlist_connect);
    }
 
    // send reconnect var request
    if (sv_force_reconnect->string[0] && !sv_client->reconnected) {
        SV_ClientCommand(sv_client, "cmd \177c connect $%s\n",
                         sv_client->reconnect_var);
    }
 
    Com_DPrintf("Going from cs_connected to cs_primed for %s\n",
                sv_client->name);
    sv_client->state = cs_primed;
 
    memset(&sv_client->lastcmd, 0, sizeof(sv_client->lastcmd));
 
    if (sv.state == ss_pic || sv.state == ss_cinematic)
        return;
 
#if USE_ZLIB
    if (sv_client->has_zlib) {
        if (sv_client->netchan->type == NETCHAN_NEW) {
            write_compressed_gamestate();
        } else {
            // FIXME: Z_SYNC_FLUSH is not efficient for baselines
            write_compressed_configstrings();
            write_plain_baselines();
        }
    } else
#endif // USE_ZLIB
    {
        write_plain_configstrings();
        write_plain_baselines();
    }
 
    // send next command
    SV_ClientCommand(sv_client, "precache %i\n", sv_client->spawncount);
}

Referenced by SV_Begin_f().

SV_NewClientExecuteMove()

static void SV_NewClientExecuteMove ( int  c )

static

Definition at line 1168 of file user.c.

{
    usercmd_t   cmds[MAX_PACKET_FRAMES][MAX_PACKET_USERCMDS];
    usercmd_t   *lastcmd, *cmd;
    int         lastframe;
    int         numCmds[MAX_PACKET_FRAMES], numDups;
    int         i, j, lightlevel;
    int         net_drop;
 
    if (moveIssued) {
        SV_DropClient(sv_client, "multiple clc_move commands in packet");
        return;     // someone is trying to cheat...
    }
 
    moveIssued = qtrue;
 
    numDups = c >> SVCMD_BITS;
    c &= SVCMD_MASK;
 
    if (numDups >= MAX_PACKET_FRAMES) {
        SV_DropClient(sv_client, "too many frames in packet");
        return;
    }
 
    if (c == clc_move_nodelta) {
        lastframe = -1;
    } else {
        lastframe = MSG_ReadLong();
    }
 
    lightlevel = MSG_ReadByte();
 
    // read all cmds
    lastcmd = NULL;
    for (i = 0; i <= numDups; i++) {
        numCmds[i] = MSG_ReadBits(5);
        if (numCmds[i] == -1) {
            SV_DropClient(sv_client, "read past end of message");
            return;
        }
        if (numCmds[i] >= MAX_PACKET_USERCMDS) {
            SV_DropClient(sv_client, "too many usercmds in frame");
            return;
        }
        for (j = 0; j < numCmds[i]; j++) {
            if (msg_read.readcount > msg_read.cursize) {
                SV_DropClient(sv_client, "read past end of message");
                return;
            }
            cmd = &cmds[i][j];
            MSG_ReadDeltaUsercmd_Enhanced(lastcmd, cmd, sv_client->version);
            cmd->lightlevel = lightlevel;
            lastcmd = cmd;
        }
    }
 
    if (sv_client->state != cs_spawned) {
        SV_SetLastFrame(-1);
        return;
    }
 
    SV_SetLastFrame(lastframe);
 
    if (q_unlikely(!lastcmd)) {
        return; // should never happen
    }
 
    net_drop = sv_client->netchan->dropped;
    if (net_drop > numDups) {
        sv_client->frameflags |= FF_CLIENTPRED;
    }
 
    if (net_drop < 20) {
        // run lastcmd multiple times if no backups available
        while (net_drop > numDups) {
            SV_ClientThink(&sv_client->lastcmd);
            net_drop--;
        }
 
        // run backup cmds, if any
        while (net_drop > 0) {
            i = numDups - net_drop;
            for (j = 0; j < numCmds[i]; j++) {
                SV_ClientThink(&cmds[i][j]);
            }
            net_drop--;
        }
 
    }
 
    // run new cmds
    for (j = 0; j < numCmds[numDups]; j++) {
        SV_ClientThink(&cmds[numDups][j]);
    }
 
    sv_client->lastcmd = *lastcmd;
}

Referenced by SV_ExecuteClientMessage().

SV_NextDownload_f()

static void SV_NextDownload_f ( void  )

static

Definition at line 566 of file user.c.

{
    if (!sv_client->download)
        return;
 
    sv_client->downloadpending = qtrue;
}

SV_NextServer_f()

static void SV_NextServer_f ( void  )

static

Definition at line 766 of file user.c.

{
    char nextserver[MAX_QPATH];
    char* v = Cvar_VariableString("nextserver");
    Q_strlcpy(nextserver, v, sizeof(nextserver));
    Cvar_Set("nextserver", "");
    
    if (sv.state != ss_pic && sv.state != ss_cinematic)
        return;     // can't nextserver while playing a normal game
 
    if (Cvar_VariableInteger("deathmatch"))
        return;
 
    sv.name[0] = 0; // make sure another doesn't sneak in
 
    if (!nextserver[0])
    {
        if (Cvar_VariableInteger("coop"))
            Cbuf_AddText(&cmd_buffer, "gamemap \"*base1\"\n");
        else
            Cbuf_AddText(&cmd_buffer, "killserver\n");
    }
    else
    {
        Cbuf_AddText(&cmd_buffer, nextserver);
        Cbuf_AddText(&cmd_buffer, "\n");
    }
}

SV_NoGameData_f()

static void SV_NoGameData_f ( void  )

static

Definition at line 822 of file user.c.

{
    sv_client->nodata ^= 1;
    SV_AlignKeyFrames(sv_client);
}

SV_OldClientExecuteMove()

static void SV_OldClientExecuteMove ( void  )

static

Definition at line 1100 of file user.c.

{
    usercmd_t   oldest, oldcmd, newcmd;
    int         lastframe;
    int         net_drop;
 
    if (moveIssued) {
        SV_DropClient(sv_client, "multiple clc_move commands in packet");
        return;     // someone is trying to cheat...
    }
 
    moveIssued = qtrue;
 
    if (sv_client->protocol == PROTOCOL_VERSION_DEFAULT) {
        MSG_ReadByte();    // skip over checksum
    }
 
    lastframe = MSG_ReadLong();
 
    // read all cmds
    if (sv_client->protocol == PROTOCOL_VERSION_R1Q2 &&
        sv_client->version >= PROTOCOL_VERSION_R1Q2_UCMD) {
        MSG_ReadDeltaUsercmd_Hacked(NULL, &oldest);
        MSG_ReadDeltaUsercmd_Hacked(&oldest, &oldcmd);
        MSG_ReadDeltaUsercmd_Hacked(&oldcmd, &newcmd);
    } else {
        MSG_ReadDeltaUsercmd(NULL, &oldest);
        MSG_ReadDeltaUsercmd(&oldest, &oldcmd);
        MSG_ReadDeltaUsercmd(&oldcmd, &newcmd);
    }
 
    if (sv_client->state != cs_spawned) {
        SV_SetLastFrame(-1);
        return;
    }
 
    SV_SetLastFrame(lastframe);
 
    net_drop = sv_client->netchan->dropped;
    if (net_drop > 2) {
        sv_client->frameflags |= FF_CLIENTPRED;
    }
 
    if (net_drop < 20) {
        // run lastcmd multiple times if no backups available
        while (net_drop > 2) {
            SV_ClientThink(&sv_client->lastcmd);
            net_drop--;
        }
 
        // run backup cmds
        if (net_drop > 1)
            SV_ClientThink(&oldest);
        if (net_drop > 0)
            SV_ClientThink(&oldcmd);
    }
 
    // run new cmd
    SV_ClientThink(&newcmd);
 
    sv_client->lastcmd = newcmd;
}

Referenced by SV_ExecuteClientMessage().

SV_ParseClientCommand()

static void SV_ParseClientCommand ( void  )

static

Definition at line 1452 of file user.c.

{
    char buffer[MAX_STRING_CHARS];
    size_t len;
 
    len = MSG_ReadString(buffer, sizeof(buffer));
    if (len >= sizeof(buffer)) {
        SV_DropClient(sv_client, "oversize stringcmd");
        return;
    }
 
    // malicious users may try using too many string commands
    if (stringCmdCount >= MAX_PACKET_STRINGCMDS) {
        Com_DPrintf("Too many stringcmds from %s\n", sv_client->name);
        return;
    }
 
    Com_DDPrintf("%s(%s): %s\n", __func__, sv_client->name, buffer);
 
    SV_ExecuteUserCommand(buffer);
    stringCmdCount++;
}

Referenced by SV_ExecuteClientMessage().

SV_ParseClientSetting()

static void SV_ParseClientSetting ( void  )

static

Definition at line 1432 of file user.c.

{
    int idx, value;
 
    idx = MSG_ReadShort();
    value = MSG_ReadShort();
 
    Com_DDPrintf("%s(%s): [%d] = %d\n", __func__, sv_client->name, idx, value);
 
    if (idx < 0 || idx >= CLS_MAX)
        return;
 
    sv_client->settings[idx] = value;
 
#if USE_FPS
    if (idx == CLS_FPS && sv_client->protocol == PROTOCOL_VERSION_Q2PRO)
        set_client_fps(value);
#endif
}

Referenced by SV_ExecuteClientMessage().

SV_ParseDeltaUserinfo()

static void SV_ParseDeltaUserinfo ( void  )

static

Definition at line 1334 of file user.c.

{
    char key[MAX_INFO_KEY], value[MAX_INFO_VALUE];
    size_t len;
 
    // malicious users may try sending too many userinfo updates
    if (userinfoUpdateCount >= MAX_PACKET_USERINFOS) {
        Com_DPrintf("Too many userinfos from %s\n", sv_client->name);
        MSG_ReadString(NULL, 0);
        MSG_ReadString(NULL, 0);
        return;
    }
 
    // optimize by combining multiple delta updates into one (hack)
    while (1) {
        len = MSG_ReadString(key, sizeof(key));
        if (len >= sizeof(key)) {
            SV_DropClient(sv_client, "oversize delta key");
            return;
        }
 
        len = MSG_ReadString(value, sizeof(value));
        if (len >= sizeof(value)) {
            SV_DropClient(sv_client, "oversize delta value");
            return;
        }
 
        if (userinfoUpdateCount < MAX_PACKET_USERINFOS) {
            if (!Info_SetValueForKey(sv_client->userinfo, key, value)) {
                SV_DropClient(sv_client, "malformed userinfo");
                return;
            }
 
            Com_DDPrintf("%s(%s): %s %s [%d]\n", __func__,
                         sv_client->name, key, value, userinfoUpdateCount);
 
            userinfoUpdateCount++;
        } else {
            Com_DPrintf("Too many userinfos from %s\n", sv_client->name);
        }
 
        if (msg_read.readcount >= msg_read.cursize)
            break; // end of message
 
        if (msg_read.data[msg_read.readcount] != clc_userinfo_delta)
            break; // not delta userinfo
 
        msg_read.readcount++;
    }
 
    SV_UpdateUserinfo();
}

Referenced by SV_ExecuteClientMessage().

SV_ParseFullUserinfo()

static void SV_ParseFullUserinfo ( void  )

static

Definition at line 1310 of file user.c.

{
    size_t len;
 
    // malicious users may try sending too many userinfo updates
    if (userinfoUpdateCount >= MAX_PACKET_USERINFOS) {
        Com_DPrintf("Too many userinfos from %s\n", sv_client->name);
        MSG_ReadString(NULL, 0);
        return;
    }
 
    len = MSG_ReadString(sv_client->userinfo, sizeof(sv_client->userinfo));
    if (len >= sizeof(sv_client->userinfo)) {
        SV_DropClient(sv_client, "oversize userinfo");
        return;
    }
 
    Com_DDPrintf("%s(%s): %s [%d]\n", __func__,
                 sv_client->name, sv_client->userinfo, userinfoUpdateCount);
 
    SV_UpdateUserinfo();
    userinfoUpdateCount++;
}

Referenced by SV_ExecuteClientMessage().

SV_SetLastFrame()

static void SV_SetLastFrame ( int  lastframe )

static

Definition at line 1067 of file user.c.

{
    client_frame_t *frame;
 
    if (lastframe > 0) {
        if (lastframe >= sv_client->framenum)
            return; // ignore invalid acks
 
        if (lastframe <= sv_client->lastframe)
            return; // ignore duplicate acks
 
        if (sv_client->framenum - lastframe <= UPDATE_BACKUP) {
            frame = &sv_client->frames[lastframe & UPDATE_MASK];
 
            if (frame->number == lastframe) {
                // save time for ping calc
                if (frame->sentTime <= com_eventTime)
                    frame->latency = com_eventTime - frame->sentTime;
            }
        }
 
        // count valid ack
        sv_client->frames_acked++;
    }
 
    sv_client->lastframe = lastframe;
}

Referenced by SV_NewClientExecuteMove(), and SV_OldClientExecuteMove().

SV_ShowMiscInfo_f()

static void SV_ShowMiscInfo_f ( void  )

static

Definition at line 815 of file user.c.

{
    SV_ClientRedirect();
    SV_PrintMiscInfo();
    Com_EndRedirect();
}

SV_ShowServerInfo_f()

static void SV_ShowServerInfo_f ( void  )

static

Definition at line 803 of file user.c.

{
    char serverinfo[MAX_INFO_STRING];
 
    Cvar_BitInfo(serverinfo, CVAR_SERVERINFO);
 
    SV_ClientRedirect();
    Info_Print(serverinfo);
    Com_EndRedirect();
}

SV_StopDownload_f()

static void SV_StopDownload_f ( void  )

static

Definition at line 743 of file user.c.

{
    int percent;
 
    if (!sv_client->download)
        return;
 
    percent = sv_client->downloadcount * 100 / sv_client->downloadsize;
 
    MSG_WriteByte(svc_download);
    MSG_WriteShort(-1);
    MSG_WriteByte(percent);
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
 
    Com_DPrintf("Download of %s to %s stopped by user request\n",
                sv_client->downloadname, sv_client->name);
    SV_CloseDownload(sv_client);
    SV_AlignKeyFrames(sv_client);
}

SV_UpdateUserinfo()

static void SV_UpdateUserinfo ( void  )

static

Definition at line 1273 of file user.c.

{
    char *s;
 
    if (!sv_client->userinfo[0]) {
        SV_DropClient(sv_client, "empty userinfo");
        return;
    }
 
    if (!Info_Validate(sv_client->userinfo)) {
        SV_DropClient(sv_client, "malformed userinfo");
        return;
    }
 
    // validate name
    s = Info_ValueForKey(sv_client->userinfo, "name");
    s[MAX_CLIENT_NAME - 1] = 0;
    if (COM_IsWhite(s) || (sv_client->name[0] && strcmp(sv_client->name, s) &&
                           SV_RateLimited(&sv_client->ratelimit_namechange))) {
        if (!sv_client->name[0]) {
            SV_DropClient(sv_client, "malformed name");
            return;
        }
        if (!Info_SetValueForKey(sv_client->userinfo, "name", sv_client->name)) {
            SV_DropClient(sv_client, "oversize userinfo");
            return;
        }
        if (COM_IsWhite(s))
            SV_ClientPrintf(sv_client, PRINT_HIGH, "You can't have an empty name.\n");
        else
            SV_ClientPrintf(sv_client, PRINT_HIGH, "You can't change your name too often.\n");
        SV_ClientCommand(sv_client, "set name \"%s\"\n", sv_client->name);
    }
 
    SV_UserinfoChanged(sv_client);
}

Referenced by SV_ParseDeltaUserinfo(), and SV_ParseFullUserinfo().

write_baseline()

static void write_baseline ( entity_packed_t *  base )

static

Definition at line 119 of file user.c.

{
    msgEsFlags_t flags = sv_client->esFlags | MSG_ES_FORCE;
 
    if (Q2PRO_SHORTANGLES(sv_client, base->number)) {
        flags |= MSG_ES_SHORTANGLES;
    }
 
    MSG_WriteDeltaEntity(NULL, base, flags);
}

Referenced by write_plain_baselines().

write_plain_baselines()

static void write_plain_baselines ( void  )

static

Definition at line 130 of file user.c.

{
    int i, j;
    entity_packed_t *base;
 
    // write a packet full of data
    for (i = 0; i < SV_BASELINES_CHUNKS; i++) {
        base = sv_client->baselines[i];
        if (!base) {
            continue;
        }
        for (j = 0; j < SV_BASELINES_PER_CHUNK; j++) {
            if (base->number) {
                // check if this baseline will overflow
                if (msg_write.cursize + 64 > sv_client->netchan->maxpacketlen) {
                    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
                }
 
                MSG_WriteByte(svc_spawnbaseline);
                write_baseline(base);
            }
            base++;
        }
    }
 
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by SV_New_f().

write_plain_configstrings()

static void write_plain_configstrings ( void  )

static

Definition at line 89 of file user.c.

{
    int     i;
    char    *string;
    size_t  length;
 
    // write a packet full of data
    string = sv_client->configstrings;
    for (i = 0; i < MAX_CONFIGSTRINGS; i++, string += MAX_QPATH) {
        if (!string[0]) {
            continue;
        }
        length = strlen(string);
        if (length > MAX_QPATH) {
            length = MAX_QPATH;
        }
        // check if this configstring will overflow
        if (msg_write.cursize + length + 64 > sv_client->netchan->maxpacketlen) {
            SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
        }
 
        MSG_WriteByte(svc_configstring);
        MSG_WriteShort(i);
        MSG_WriteData(string, length);
        MSG_WriteByte(0);
    }
 
    SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by SV_New_f().

Variable Documentation

moveIssued

qboolean moveIssued

static

Definition at line 1034 of file user.c.

Referenced by SV_ExecuteClientMessage(), SV_NewClientExecuteMove(), and SV_OldClientExecuteMove().

stringCmdCount

int stringCmdCount

static

Definition at line 1035 of file user.c.

Referenced by SV_ExecuteClientMessage(), and SV_ParseClientCommand().

ucmds

const ucmd_t ucmds[]

static

Initial value:

= {
    
    { "new", SV_New_f },
    { "begin", SV_Begin_f },
    { "baselines", NULL },
    { "configstrings", NULL },
    { "nextserver", SV_NextServer_f },
    { "disconnect", SV_Disconnect_f },
 
    
    { "info", SV_ShowServerInfo_f },
    { "sinfo", SV_ShowMiscInfo_f },
 
    { "download", SV_BeginDownload_f },
    { "nextdl", SV_NextDownload_f },
    { "stopdl", SV_StopDownload_f },
 
    { "\177c", SV_CvarResult_f },
    { "nogamedata", SV_NoGameData_f },
    { "lag", SV_Lag_f },
 
 
 
    { "aclist", SV_AC_List_f },
    { "acinfo", SV_AC_Info_f },
 
    { NULL, NULL }
}

Definition at line 920 of file user.c.

Referenced by SV_ExecuteUserCommand().

userinfoUpdateCount

int userinfoUpdateCount

static

Definition at line 1036 of file user.c.

Referenced by SV_ExecuteClientMessage(), SV_ParseDeltaUserinfo(), and SV_ParseFullUserinfo().