cl_cmd.c File Reference

#include "quakedef.h"
#include "hmac.h"
#include "mdfour.h"
#include "image.h"
#include <time.h>
#include "cl_collision.h"

Include dependency graph for cl_cmd.c:

Go to the source code of this file.

Functions
static void	CL_Bottomcolor_c (cvar_t *var)
static void	CL_Color_c (cvar_t *var)
static void	CL_Color_f (cmd_state_t *cmd)
void	CL_ForwardToServer (const char *s)
	adds the string as a clc_stringcmd to the client message.
void	CL_ForwardToServer_f (cmd_state_t *cmd)
	adds the current command line as a clc_stringcmd to the client message.
static void	CL_FullInfo_f (cmd_state_t *cmd)
static void	CL_FullServerinfo_f (cmd_state_t *cmd)
void	CL_InitCommands (void)
static void	CL_Name_f (cmd_state_t *cmd)
static void	CL_Packet_f (cmd_state_t *cmd)
static void	CL_PingPLReport_f (cmd_state_t *cmd)
static void	CL_PQRcon_f (cmd_state_t *cmd)
static void	CL_Rcon_f (cmd_state_t *cmd)
static void	CL_SendCvar_f (cmd_state_t *cmd)
static void	CL_SetInfo_f (cmd_state_t *cmd)
static void	CL_Topcolor_c (cvar_t *var)
static void	CL_User_f (cmd_state_t *cmd)
static void	CL_Users_f (cmd_state_t *cmd)

Variables
cvar_t	cl_bottomcolor = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "bottomcolor", "0", "color of your pants"}
cvar_t	cl_color = {CF_CLIENT | CF_ARCHIVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"}
cvar_t	cl_name = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "_cl_name", "player", "player name"}
	User-visible names of these CF_USERINFO cvars must be matched in CL_SetInfo()!
cvar_t	cl_noaim = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "noaim", "1", "QW option to disable vertical autoaim"}
cvar_t	cl_pmodel = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "pmodel", "0", "current player model number in nehahra"}
cvar_t	cl_rate = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate", "20000", "connection speed"}
cvar_t	cl_rate_burstsize = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate_burstsize", "1024", "rate control burst size"}
cvar_t	cl_skin = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "skin", "", "QW player skin name (example: base)"}
cvar_t	cl_team = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "team", "none", "QW team (4 character limit, example: blue)"}
cvar_t	cl_topcolor = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "topcolor", "0", "color of your shirt"}
cvar_t	r_fixtrans_auto = {CF_CLIENT, "r_fixtrans_auto", "0", "automatically fixtrans textures (when set to 2, it also saves the fixed versions to a fixtrans directory)"}
cvar_t	rcon_secure
cvar_t	rcon_secure_challengetimeout

Function Documentation

CL_Bottomcolor_c()

static void CL_Bottomcolor_c ( cvar_t * var )

static

Definition at line 282 of file cl_cmd.c.

{
    char vabuf[1024];
    void (*callback_save)(cvar_t *);
 
    callback_save = cl_color.callback;
    cl_color.callback = NULL;
    Cvar_SetQuick(&cl_color, va(vabuf, sizeof(vabuf), "%i", cl_topcolor.integer*16 + var->integer));
    cl_color.callback = callback_save;
}

References cvar_t::callback, cl_color, cl_topcolor, Cvar_SetQuick(), cvar_t::integer, NULL, va(), and void().

Referenced by CL_InitCommands().

CL_Color_c()

static void CL_Color_c ( cvar_t * var )

static

Definition at line 255 of file cl_cmd.c.

{
    char vabuf[1024];
    void (*callback_save)(cvar_t *);
 
    callback_save = cl_topcolor.callback;
    cl_topcolor.callback = NULL;
    Cvar_SetQuick(&cl_topcolor, va(vabuf, sizeof(vabuf), "%i", ((var->integer >> 4) & 15)));
    cl_topcolor.callback = callback_save;
 
    callback_save = cl_bottomcolor.callback;
    cl_bottomcolor.callback = NULL;
    Cvar_SetQuick(&cl_bottomcolor, va(vabuf, sizeof(vabuf), "%i", (var->integer & 15)));
    cl_bottomcolor.callback = callback_save;
}

References cvar_t::callback, cl_bottomcolor, cl_topcolor, Cvar_SetQuick(), cvar_t::integer, NULL, va(), and void().

Referenced by CL_InitCommands().

CL_Color_f()

static void CL_Color_f ( cmd_state_t * cmd )

static

Definition at line 293 of file cl_cmd.c.

{
    int top, bottom;
 
    if (Cmd_Argc(cmd) == 1)
    {
        if (cmd->source == src_local)
        {
            Con_Printf("\"color\" is \"%i %i\"\n", cl_topcolor.integer, cl_bottomcolor.integer);
            Con_Print("color <0-15> [0-15]\n");
        }
        return;
    }
 
    if (Cmd_Argc(cmd) == 2)
        top = bottom = atoi(Cmd_Argv(cmd, 1));
    else
    {
        top = atoi(Cmd_Argv(cmd, 1));
        bottom = atoi(Cmd_Argv(cmd, 2));
    }
    /*
     * This is just a convenient way to change topcolor and bottomcolor
     * We can't change cl_color from here directly because topcolor and
     * bottomcolor may be changed separately and do not call this function.
     * So it has to be changed when the userinfo strings are updated, which
     * happens twice here. Perhaps find a cleaner way?
     */
 
    top = top >= 0 ? top : cl_topcolor.integer;
    bottom = bottom >= 0 ? bottom : cl_bottomcolor.integer;
 
    top &= 15;
    bottom &= 15;
 
    // LadyHavoc: allowing skin colormaps 14 and 15 by commenting this out
    //if (top > 13)
    //  top = 13;
    //if (bottom > 13)
    //  bottom = 13;
 
    if (cmd->source == src_local)
    {
        Cvar_SetValueQuick(&cl_topcolor, top);
        Cvar_SetValueQuick(&cl_bottomcolor, bottom);
        return;
    }
}

References cl_bottomcolor, cl_topcolor, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), Cvar_SetValueQuick(), cvar_t::integer, and src_local.

Referenced by CL_InitCommands().

CL_ForwardToServer()

void CL_ForwardToServer

(

const char *

s

)

adds the string as a clc_stringcmd to the client message.

(used when there is no reason to generate a local command to do it)

Definition at line 54 of file cl_cmd.c.

{
    char temp[128];
    if (cls.state != ca_connected)
    {
        Con_Printf("Can't \"%s\", not connected\n", s);
        return;
    }
 
    if (!cls.netcon)
        return;
 
    // LadyHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
    // attention, it has been eradicated from here, its only (former) use in
    // all of darkplaces.
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
    else
        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
    if ((!strncmp(s, "say ", 4) || !strncmp(s, "say_team ", 9)) && cl_locs_enable.integer)
    {
        // say/say_team commands can replace % character codes with status info
        while (*s)
        {
            if (*s == '%' && s[1])
            {
                // handle proquake message macros
                temp[0] = 0;
                switch (s[1])
                {
                case 'l': // current location
                    CL_Locs_FindLocationName(temp, sizeof(temp), cl.movement_origin);
                    break;
                case 'h': // current health
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_HEALTH]);
                    break;
                case 'a': // current armor
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ARMOR]);
                    break;
                case 'x': // current rockets
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ROCKETS]);
                    break;
                case 'c': // current cells
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_CELLS]);
                    break;
                // silly proquake macros
                case 'd': // loc at last death
                    CL_Locs_FindLocationName(temp, sizeof(temp), cl.lastdeathorigin);
                    break;
                case 't': // current time
                    dpsnprintf(temp, sizeof(temp), "%.0f:%.0f", floor(cl.time / 60), cl.time - floor(cl.time / 60) * 60);
                    break;
                case 'r': // rocket launcher status ("I have RL", "I need rockets", "I need RL")
                    if (!(cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER))
                        dpsnprintf(temp, sizeof(temp), "I need RL");
                    else if (!cl.stats[STAT_ROCKETS])
                        dpsnprintf(temp, sizeof(temp), "I need rockets");
                    else
                        dpsnprintf(temp, sizeof(temp), "I have RL");
                    break;
                case 'p': // powerup status (outputs "quad" "pent" and "eyes" according to status)
                    if (cl.stats[STAT_ITEMS] & IT_QUAD)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "quad", sizeof(temp));
                    }
                    if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "pent", sizeof(temp));
                    }
                    if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "eyes", sizeof(temp));
                    }
                    break;
                case 'w': // weapon status (outputs "SSG:NG:SNG:GL:RL:LG" with the text between : characters omitted if you lack the weapon)
                    if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN)
                        dp_strlcat(temp, "SSG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_NAILGUN)
                        dp_strlcat(temp, "NG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN)
                        dp_strlcat(temp, "SNG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER)
                        dp_strlcat(temp, "GL", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)
                        dp_strlcat(temp, "RL", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_LIGHTNING)
                        dp_strlcat(temp, "LG", sizeof(temp));
                    break;
                default:
                    // not a recognized macro, print it as-is...
                    temp[0] = s[0];
                    temp[1] = s[1];
                    temp[2] = 0;
                    break;
                }
                // write the resulting text
                SZ_Write(&cls.netcon->message, (unsigned char *)temp, (int)strlen(temp));
                s += 2;
                continue;
            }
            MSG_WriteByte(&cls.netcon->message, *s);
            s++;
        }
        MSG_WriteByte(&cls.netcon->message, 0);
    }
    else // any other command is passed on as-is
        SZ_Write(&cls.netcon->message, (const unsigned char *)s, (int)strlen(s) + 1);
}

References ca_connected, cl, cl_locs_enable, CL_Locs_FindLocationName(), clc_stringcmd, cls, Con_Printf(), dp_strlcat, dpsnprintf(), floor(), cvar_t::integer, IT_GRENADE_LAUNCHER, IT_INVISIBILITY, IT_INVULNERABILITY, IT_LIGHTNING, IT_NAILGUN, IT_QUAD, IT_ROCKET_LAUNCHER, IT_SUPER_NAILGUN, IT_SUPER_SHOTGUN, client_state_t::lastdeathorigin, netconn_t::message, client_state_t::movement_origin, MSG_WriteByte(), client_static_t::netcon, client_static_t::protocol, PROTOCOL_QUAKEWORLD, qw_clc_stringcmd, STAT_ARMOR, STAT_CELLS, STAT_HEALTH, STAT_ITEMS, STAT_ROCKETS, client_static_t::state, client_state_t::stats, strlen(), SZ_Write(), and client_state_t::time.

Referenced by CL_BeginDownloads(), CL_DownloadBegin_f(), CL_ForwardToServer_f(), CL_SendCvar_f(), Key_Message(), and NetConn_ConnectionEstablished().

CL_ForwardToServer_f()

void CL_ForwardToServer_f

(

cmd_state_t *

cmd

)

adds the current command line as a clc_stringcmd to the client message.

things like godmode, noclip, etc, are commands directed to the server, so when they are typed in at the console, they will need to be forwarded.

Definition at line 174 of file cl_cmd.c.

{
    const char *s;
    char vabuf[MAX_INPUTLINE];
    size_t i;
    if (!strcasecmp(Cmd_Argv(cmd, 0), "cmd"))
    {
        // we want to strip off "cmd", so just send the args
        s = Cmd_Argc(cmd) > 1 ? Cmd_Args(cmd) : "";
    }
    else
    {
        // we need to keep the command name, so send Cmd_Argv(cmd, 0), a space and then Cmd_Args(cmd)
        i = dpsnprintf(vabuf, sizeof(vabuf), "%s", Cmd_Argv(cmd, 0));
        if(Cmd_Argc(cmd) > 1)
            // (i + 1) accounts for the added space
            dpsnprintf(&vabuf[i], sizeof(vabuf) - (i + 1), " %s", Cmd_Args(cmd));
        s = vabuf;
    }
    // don't send an empty forward message if the user tries "cmd" by itself
    if (!s || !*s)
        return;
    CL_ForwardToServer(s);
}

References CL_ForwardToServer(), cmd(), Cmd_Argc(), Cmd_Args(), Cmd_Argv(), dpsnprintf(), i, and MAX_INPUTLINE.

Referenced by CL_InitCommands(), and Cmd_CL_Callback().

CL_FullInfo_f()

static void CL_FullInfo_f ( cmd_state_t * cmd )

static

Definition at line 655 of file cl_cmd.c.

{
    char key[512];
    char value[512];
    const char *s;
 
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Printf ("fullinfo <complete info string>\n");
        return;
    }
 
    s = Cmd_Argv(cmd, 1);
    if (*s == '\\')
        s++;
    while (*s)
    {
        size_t len = strcspn(s, "\\");
        if (len >= sizeof(key)) {
            len = sizeof(key) - 1;
        }
        dp_strlcpy(key, s, len + 1);
        s += len;
        if (!*s)
        {
            Con_Printf ("MISSING VALUE\n");
            return;
        }
        ++s; // Skip over backslash.
 
        len = strcspn(s, "\\");
        if (len >= sizeof(value)) {
            len = sizeof(value) - 1;
        }
        dp_strlcpy(value, s, len + 1);
 
        CL_SetInfo(key, value, false, false, false, false);
 
        s += len;
        if (!*s)
        {
            break;
        }
        ++s; // Skip over backslash.
    }
}

References CL_SetInfo(), cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), dp_strlcpy, and value.

Referenced by CL_InitCommands().

CL_FullServerinfo_f()

static void CL_FullServerinfo_f ( cmd_state_t * cmd )

static

Definition at line 633 of file cl_cmd.c.

{
    char temp[512];
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Printf ("usage: fullserverinfo <complete info string>\n");
        return;
    }
 
    dp_strlcpy (cl.qw_serverinfo, Cmd_Argv(cmd, 1), sizeof(cl.qw_serverinfo));
    InfoString_GetValue(cl.qw_serverinfo, "teamplay", temp, sizeof(temp));
    cl.qw_teamplay = atoi(temp);
}

References cl, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), dp_strlcpy, InfoString_GetValue(), client_state_t::qw_serverinfo, and client_state_t::qw_teamplay.

Referenced by CL_InitCommands().

CL_InitCommands()

void CL_InitCommands

(

void

)

Definition at line 742 of file cl_cmd.c.

{
    dpsnprintf(cls.userinfo, sizeof(cls.userinfo), "\\name\\player\\team\\none\\topcolor\\0\\bottomcolor\\0\\rate\\10000\\msg\\1\\noaim\\1\\*ver\\dp");
 
    /* In Quake `name` is a command that concatenates its arguments (quotes unnecessary)
     * which is expected in most DP-based games.
     * In QuakeWorld it's a cvar which requires quotes if spaces are used.
     */
    Cvar_RegisterVariable(&cl_name);
    if ((0)) // TODO: if (gamemode == GAME_QUAKEWORLD)
        Cvar_RegisterVirtual(&cl_name, "name");
    else
        Cmd_AddCommand(CF_CLIENT, "name", CL_Name_f, "change your player name");
 
    Cvar_RegisterVariable(&cl_rate);
    Cvar_RegisterVirtual(&cl_rate, "_cl_rate");
    Cvar_RegisterVariable(&cl_rate_burstsize);
    Cvar_RegisterVirtual(&cl_rate_burstsize, "_cl_rate_burstsize");
    Cvar_RegisterVariable(&cl_pmodel);
    Cvar_RegisterVirtual(&cl_pmodel, "_cl_pmodel");
    Cvar_RegisterVariable(&cl_color);
    Cvar_RegisterCallback(&cl_color, CL_Color_c);
    Cvar_RegisterVariable(&cl_topcolor);
    Cvar_RegisterCallback(&cl_topcolor, CL_Topcolor_c);
    Cvar_RegisterVariable(&cl_bottomcolor);
    Cvar_RegisterCallback(&cl_bottomcolor, CL_Bottomcolor_c);
    Cvar_RegisterVariable(&r_fixtrans_auto);
    Cvar_RegisterVariable(&cl_team);
    Cvar_RegisterVariable(&cl_skin);
    Cvar_RegisterVariable(&cl_noaim);   
 
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "cmd", CL_ForwardToServer_f, "send a console commandline to the server (used by some mods)");
    Cmd_AddCommand(CF_CLIENT, "color", CL_Color_f, "change your player shirt and pants colors");
    Cmd_AddCommand(CF_CLIENT, "rcon", CL_Rcon_f, "sends a command to the server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's); note: if rcon_secure is set, client and server clocks must be synced e.g. via NTP");
    Cmd_AddCommand(CF_CLIENT, "srcon", CL_Rcon_f, "sends a command to the server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's); this always works as if rcon_secure is set; note: client and server clocks must be synced e.g. via NTP");
    Cmd_AddCommand(CF_CLIENT, "pqrcon", CL_PQRcon_f, "sends a command to a proquake server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's)");
    Cmd_AddCommand(CF_SHARED, "user", CL_User_f, "prints additional information about a player number or name on the scoreboard");
    Cmd_AddCommand(CF_SHARED, "users", CL_Users_f, "prints additional information about all players on the scoreboard");
    Cmd_AddCommand(CF_CLIENT, "packet", CL_Packet_f, "send a packet to the specified address:port containing a text string");
    Cmd_AddCommand(CF_CLIENT, "fullinfo", CL_FullInfo_f, "allows client to modify their userinfo");
    Cmd_AddCommand(CF_CLIENT, "setinfo", CL_SetInfo_f, "modifies your userinfo");
    Cmd_AddCommand(CF_CLIENT, "fixtrans", Image_FixTransparentPixels_f, "change alpha-zero pixels in an image file to sensible values, and write out a new TGA (warning: SLOW)");
    host.hook.CL_SendCvar = CL_SendCvar_f;
 
    // commands that are only sent by server to client for execution
    Cmd_AddCommand(CF_CLIENT_FROM_SERVER, "pingplreport", CL_PingPLReport_f, "command sent by server containing client ping and packet loss values for scoreboard, triggered by pings command from client (not used by QW servers)");
    Cmd_AddCommand(CF_CLIENT_FROM_SERVER, "fullserverinfo", CL_FullServerinfo_f, "internal use only, sent by server to client to update client's local copy of serverinfo string");
}

References CF_CLIENT, CF_CLIENT_FROM_SERVER, CF_SHARED, cl_bottomcolor, CL_Bottomcolor_c(), cl_color, CL_Color_c(), CL_Color_f(), CL_ForwardToServer_f(), CL_FullInfo_f(), CL_FullServerinfo_f(), cl_name, CL_Name_f(), cl_noaim, CL_Packet_f(), CL_PingPLReport_f(), cl_pmodel, CL_PQRcon_f(), cl_rate, cl_rate_burstsize, CL_Rcon_f(), host_static_t::CL_SendCvar, CL_SendCvar_f(), CL_SetInfo_f(), cl_skin, cl_team, cl_topcolor, CL_Topcolor_c(), CL_User_f(), CL_Users_f(), cls, Cmd_AddCommand(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), dpsnprintf(), host_static_t::hook, host, Image_FixTransparentPixels_f(), r_fixtrans_auto, and client_static_t::userinfo.

Referenced by CL_Init().

CL_Name_f()

static void CL_Name_f ( cmd_state_t * cmd )

static

Definition at line 228 of file cl_cmd.c.

{
    char *newNameSource;
 
    if (Cmd_Argc(cmd) == 1)
    {
        Con_Printf("name: \"%s^7\"\n", cl_name.string);
        return;
    }
 
    // in the single-arg case any enclosing quotes shall be stripped
    newNameSource = (char *)(Cmd_Argc(cmd) == 2 ? Cmd_Argv(cmd, 1) : Cmd_Args(cmd));
 
    if (strlen(newNameSource) >= MAX_SCOREBOARDNAME) // may as well truncate before networking
        newNameSource[MAX_SCOREBOARDNAME - 1] = '\0'; // this is fine (cbuf stores length)
 
    Cvar_SetQuick(&cl_name, newNameSource);
}

References cl_name, cmd(), Cmd_Argc(), Cmd_Args(), Cmd_Argv(), Con_Printf(), Cvar_SetQuick(), MAX_SCOREBOARDNAME, cvar_t::string, and strlen().

Referenced by CL_InitCommands().

CL_Packet_f()

static void CL_Packet_f ( cmd_state_t * cmd )

static

Definition at line 413 of file cl_cmd.c.

{
    char send[2048];
    int i, l;
    const char *in;
    char *out;
    lhnetaddress_t address;
    lhnetsocket_t *mysocket;
 
    if (Cmd_Argc(cmd) != 3)
    {
        Con_Printf ("packet <destination> <contents>\n");
        return;
    }
 
    if (!LHNETADDRESS_FromString (&address, Cmd_Argv(cmd, 1), sv_netport.integer))
    {
        Con_Printf ("Bad address\n");
        return;
    }
 
    in = Cmd_Argv(cmd, 2);
    out = send+4;
    send[0] = send[1] = send[2] = send[3] = -1;
 
    l = (int)strlen (in);
    for (i=0 ; i<l ; i++)
    {
        if (out >= send + sizeof(send) - 1)
            break;
        if (in[i] == '\\' && in[i+1] == 'n')
        {
            *out++ = '\n';
            i++;
        }
        else if (in[i] == '\\' && in[i+1] == '0')
        {
            *out++ = '\0';
            i++;
        }
        else if (in[i] == '\\' && in[i+1] == 't')
        {
            *out++ = '\t';
            i++;
        }
        else if (in[i] == '\\' && in[i+1] == 'r')
        {
            *out++ = '\r';
            i++;
        }
        else if (in[i] == '\\' && in[i+1] == '"')
        {
            *out++ = '\"';
            i++;
        }
        else
            *out++ = in[i];
    }
 
    mysocket = NetConn_ChooseClientSocketForAddress(&address);
    if (!mysocket)
        mysocket = NetConn_ChooseServerSocketForAddress(&address);
    if (mysocket)
        NetConn_Write(mysocket, send, out - send, &address);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), i, int(), cvar_t::integer, LHNETADDRESS_FromString(), NetConn_ChooseClientSocketForAddress(), NetConn_ChooseServerSocketForAddress(), NetConn_Write(), strlen(), and sv_netport.

Referenced by CL_InitCommands().

CL_PingPLReport_f()

static void CL_PingPLReport_f ( cmd_state_t * cmd )

static

Definition at line 724 of file cl_cmd.c.

{
    char *errbyte;
    int i;
    int l = Cmd_Argc(cmd);
    if (l > cl.maxclients)
        l = cl.maxclients;
    for (i = 0;i < l;i++)
    {
        cl.scores[i].qw_ping = atoi(Cmd_Argv(cmd, 1+i*2));
        cl.scores[i].qw_packetloss = strtol(Cmd_Argv(cmd, 1+i*2+1), &errbyte, 0);
        if(errbyte && *errbyte == ',')
            cl.scores[i].qw_movementloss = atoi(errbyte + 1);
        else
            cl.scores[i].qw_movementloss = 0;
    }
}

References cl, cmd(), Cmd_Argc(), Cmd_Argv(), i, client_state_t::maxclients, scoreboard_t::qw_movementloss, scoreboard_t::qw_packetloss, scoreboard_t::qw_ping, and client_state_t::scores.

Referenced by CL_InitCommands().

CL_PQRcon_f()

static void CL_PQRcon_f ( cmd_state_t * cmd )

static

Definition at line 486 of file cl_cmd.c.

{
    int n;
    const char *e;
    lhnetsocket_t *mysocket;
 
    if (Cmd_Argc(cmd) == 1)
    {
        Con_Printf("%s: Usage: %s command\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0));
        return;
    }
 
    if (!rcon_password.string || !rcon_password.string[0] || rcon_secure.integer > 0)
    {
        Con_Printf ("You must set rcon_password before issuing an pqrcon command, and rcon_secure must be 0.\n");
        return;
    }
 
    e = strchr(rcon_password.string, ' ');
    n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
 
    if (cls.netcon)
        cls.rcon_address = cls.netcon->peeraddress;
    else
    {
        if (!rcon_address.string[0])
        {
            Con_Printf ("You must either be connected, or set the rcon_address cvar to issue rcon commands\n");
            return;
        }
        LHNETADDRESS_FromString(&cls.rcon_address, rcon_address.string, sv_netport.integer);
    }
    mysocket = NetConn_ChooseClientSocketForAddress(&cls.rcon_address);
    if (mysocket)
    {
        sizebuf_t buf;
        unsigned char bufdata[64];
        buf.data = bufdata;
        SZ_Clear(&buf);
        MSG_WriteLong(&buf, 0);
        MSG_WriteByte(&buf, CCREQ_RCON);
        SZ_Write(&buf, (const unsigned char*)rcon_password.string, n);
        MSG_WriteByte(&buf, 0); // terminate the (possibly partial) string
        MSG_WriteString(&buf, Cmd_Args(cmd));
        StoreBigLong(buf.data, NETFLAG_CTL | (buf.cursize & NETFLAG_LENGTH_MASK));
        NetConn_Write(mysocket, buf.data, buf.cursize, &cls.rcon_address);
        SZ_Clear(&buf);
    }
}

References buf, CCREQ_RCON, cls, cmd(), Cmd_Argc(), Cmd_Args(), Cmd_Argv(), Con_Printf(), int(), cvar_t::integer, LHNETADDRESS_FromString(), MSG_WriteByte(), MSG_WriteLong(), MSG_WriteString(), n, client_static_t::netcon, NetConn_ChooseClientSocketForAddress(), NetConn_Write(), NETFLAG_CTL, NETFLAG_LENGTH_MASK, netconn_t::peeraddress, client_static_t::rcon_address, rcon_address, rcon_password, rcon_secure, StoreBigLong(), cvar_t::string, strlen(), sv_netport, SZ_Clear(), and SZ_Write().

Referenced by CL_InitCommands().

CL_Rcon_f()

static void CL_Rcon_f ( cmd_state_t * cmd )

static

Definition at line 544 of file cl_cmd.c.

{
    int i, n;
    const char *e;
    lhnetsocket_t *mysocket;
 
    if (Cmd_Argc(cmd) == 1)
    {
        Con_Printf("%s: Usage: %s command\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0));
        return;
    }
 
    if (!rcon_password.string || !rcon_password.string[0])
    {
        Con_Printf ("You must set rcon_password before issuing an rcon command.\n");
        return;
    }
 
    e = strchr(rcon_password.string, ' ');
    n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
 
    if (cls.netcon)
        cls.rcon_address = cls.netcon->peeraddress;
    else
    {
        if (!rcon_address.string[0])
        {
            Con_Printf ("You must either be connected, or set the rcon_address cvar to issue rcon commands\n");
            return;
        }
        LHNETADDRESS_FromString(&cls.rcon_address, rcon_address.string, sv_netport.integer);
    }
    mysocket = NetConn_ChooseClientSocketForAddress(&cls.rcon_address);
    if (mysocket && Cmd_Args(cmd)[0])
    {
        // simply put together the rcon packet and send it
        if(Cmd_Argv(cmd, 0)[0] == 's' || rcon_secure.integer > 1)
        {
            if(cls.rcon_commands[cls.rcon_ringpos][0])
            {
                char s[128];
                LHNETADDRESS_ToString(&cls.rcon_addresses[cls.rcon_ringpos], s, sizeof(s), true);
                Con_Printf("rcon to %s (for command %s) failed: too many buffered commands (possibly increase MAX_RCONS)\n", s, cls.rcon_commands[cls.rcon_ringpos]);
                cls.rcon_commands[cls.rcon_ringpos][0] = 0;
                --cls.rcon_trying;
            }
            for (i = 0;i < MAX_RCONS;i++)
                if(cls.rcon_commands[i][0])
                    if (!LHNETADDRESS_Compare(&cls.rcon_address, &cls.rcon_addresses[i]))
                        break;
            ++cls.rcon_trying;
            if(i >= MAX_RCONS)
                NetConn_WriteString(mysocket, "\377\377\377\377getchallenge", &cls.rcon_address); // otherwise we'll request the challenge later
            dp_strlcpy(cls.rcon_commands[cls.rcon_ringpos], Cmd_Args(cmd), sizeof(cls.rcon_commands[cls.rcon_ringpos]));
            cls.rcon_addresses[cls.rcon_ringpos] = cls.rcon_address;
            cls.rcon_timeout[cls.rcon_ringpos] = host.realtime + rcon_secure_challengetimeout.value;
            cls.rcon_ringpos = (cls.rcon_ringpos + 1) % MAX_RCONS;
        }
        else if(rcon_secure.integer > 0)
        {
            char buf[1500];
            char argbuf[1500];
            dpsnprintf(argbuf, sizeof(argbuf), "%ld.%06d %s", (long) time(NULL), (int) (rand() % 1000000), Cmd_Args(cmd));
            memcpy(buf, "\377\377\377\377srcon HMAC-MD4 TIME ", 24);
            if(HMAC_MDFOUR_16BYTES((unsigned char *) (buf + 24), (unsigned char *) argbuf, (int)strlen(argbuf), (unsigned char *) rcon_password.string, n))
            {
                buf[40] = ' ';
                dp_strlcpy(buf + 41, argbuf, sizeof(buf) - 41);
                NetConn_Write(mysocket, buf, 41 + (int)strlen(buf + 41), &cls.rcon_address);
            }
        }
        else
        {
            char buf[1500];
            memcpy(buf, "\377\377\377\377", 4);
            dpsnprintf(buf+4, sizeof(buf)-4, "rcon %.*s %s",  n, rcon_password.string, Cmd_Args(cmd));
            NetConn_WriteString(mysocket, buf, &cls.rcon_address);
        }
    }
}

References buf, cls, cmd(), Cmd_Argc(), Cmd_Args(), Cmd_Argv(), Con_Printf(), dp_strlcpy, dpsnprintf(), HMAC_MDFOUR_16BYTES, host, i, int(), cvar_t::integer, LHNETADDRESS_Compare(), LHNETADDRESS_FromString(), LHNETADDRESS_ToString(), MAX_RCONS, n, client_static_t::netcon, NetConn_ChooseClientSocketForAddress(), NetConn_Write(), NetConn_WriteString(), NULL, netconn_t::peeraddress, client_static_t::rcon_address, rcon_address, client_static_t::rcon_addresses, client_static_t::rcon_commands, rcon_password, client_static_t::rcon_ringpos, rcon_secure, rcon_secure_challengetimeout, client_static_t::rcon_timeout, client_static_t::rcon_trying, host_static_t::realtime, cvar_t::string, strlen(), sv_netport, time, and cvar_t::value.

Referenced by CL_InitCommands().

CL_SendCvar_f()

static void CL_SendCvar_f ( cmd_state_t * cmd )

static

Definition at line 199 of file cl_cmd.c.

{
    cvar_t  *c;
    const char *cvarname;
    char vabuf[1024];
 
    if(Cmd_Argc(cmd) != 2)
        return;
    cvarname = Cmd_Argv(cmd, 1);
    if (cls.state == ca_connected)
    {
        c = Cvar_FindVar(&cvars_all, cvarname, CF_CLIENT | CF_SERVER);
        // LadyHavoc: if there is no such cvar or if it is private, send a
        // reply indicating that it has no value
        if(!c || (c->flags & CF_PRIVATE))
            CL_ForwardToServer(va(vabuf, sizeof(vabuf), "sentcvar %s", cvarname));
        else
            CL_ForwardToServer(va(vabuf, sizeof(vabuf), "sentcvar %s \"%s\"", c->name, c->string));
        return;
    }
}

References ca_connected, CF_CLIENT, CF_PRIVATE, CF_SERVER, CL_ForwardToServer(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Cvar_FindVar(), cvars_all, cvar_t::flags, cvar_t::name, client_static_t::state, cvar_t::string, and va().

Referenced by CL_InitCommands().

CL_SetInfo_f()

static void CL_SetInfo_f ( cmd_state_t * cmd )

static

Definition at line 709 of file cl_cmd.c.

{
    if (Cmd_Argc(cmd) == 1)
    {
        InfoString_Print(cls.userinfo);
        return;
    }
    if (Cmd_Argc(cmd) != 3)
    {
        Con_Printf ("usage: setinfo [ <key> <value> ]\n");
        return;
    }
    CL_SetInfo(Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), true, false, false, false);
}

References CL_SetInfo(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), InfoString_Print(), and client_static_t::userinfo.

Referenced by CL_InitCommands().

CL_Topcolor_c()

static void CL_Topcolor_c ( cvar_t * var )

static

Definition at line 271 of file cl_cmd.c.

{
    char vabuf[1024];
    void (*callback_save)(cvar_t *);
 
    callback_save = cl_color.callback;
    cl_color.callback = NULL;
    Cvar_SetQuick(&cl_color, va(vabuf, sizeof(vabuf), "%i", var->integer*16 + cl_bottomcolor.integer));
    cl_color.callback = callback_save;
}

References cvar_t::callback, cl_bottomcolor, cl_color, Cvar_SetQuick(), cvar_t::integer, NULL, va(), and void().

Referenced by CL_InitCommands().

CL_User_f()

static void CL_User_f ( cmd_state_t * cmd )

static

Definition at line 351 of file cl_cmd.c.

{
    int     uid;
    int     i;
 
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Printf ("Usage: user <username / userid>\n");
        return;
    }
 
    uid = atoi(Cmd_Argv(cmd, 1));
 
    for (i = 0;i < cl.maxclients;i++)
    {
        if (!cl.scores[i].name[0])
            continue;
        if (cl.scores[i].qw_userid == uid || !strcasecmp(cl.scores[i].name, Cmd_Argv(cmd, 1)))
        {
            InfoString_Print(cl.scores[i].qw_userinfo);
            return;
        }
    }
    Con_Printf ("User not in server.\n");
}

References cl, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), i, InfoString_Print(), client_state_t::maxclients, scoreboard_t::name, scoreboard_t::qw_userid, scoreboard_t::qw_userinfo, and client_state_t::scores.

Referenced by CL_InitCommands().

CL_Users_f()

static void CL_Users_f ( cmd_state_t * cmd )

static

Definition at line 384 of file cl_cmd.c.

{
    int     i;
    int     c;
 
    c = 0;
    Con_Printf ("userid frags name\n");
    Con_Printf ("------ ----- ----\n");
    for (i = 0;i < cl.maxclients;i++)
    {
        if (cl.scores[i].name[0])
        {
            Con_Printf ("%6i %4i %s\n", cl.scores[i].qw_userid, cl.scores[i].frags, cl.scores[i].name);
            c++;
        }
    }
 
    Con_Printf ("%i total users\n", c);
}

References cl, Con_Printf(), scoreboard_t::frags, i, client_state_t::maxclients, scoreboard_t::name, scoreboard_t::qw_userid, and client_state_t::scores.

Referenced by CL_InitCommands().

Variable Documentation

cl_bottomcolor

cvar_t cl_bottomcolor = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "bottomcolor", "0", "color of your pants"}

Definition at line 36 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "bottomcolor", "0", "color of your pants"};

Referenced by CL_Color_c(), CL_Color_f(), CL_InitCommands(), CL_SendPlayerInfo(), CL_SetInfo(), CL_Topcolor_c(), and M_Menu_Setup_f().

cl_color

cvar_t cl_color = {CF_CLIENT | CF_ARCHIVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"}

Definition at line 252 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"};

Referenced by CL_Bottomcolor_c(), CL_InitCommands(), and CL_Topcolor_c().

cl_name

cvar_t cl_name = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "_cl_name", "player", "player name"}

User-visible names of these CF_USERINFO cvars must be matched in CL_SetInfo()!

Definition at line 32 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "_cl_name", "player", "player name"};

Referenced by CL_InitCommands(), CL_Name_f(), CL_SendPlayerInfo(), M_Menu_Setup_f(), M_Setup_Key(), and SV_Kick_f().

cl_noaim

cvar_t cl_noaim = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "noaim", "1", "QW option to disable vertical autoaim"}

Definition at line 39 of file cl_cmd.c.

{CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "noaim", "1", "QW option to disable vertical autoaim"};

Referenced by CL_InitCommands().

cl_pmodel

cvar_t cl_pmodel = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "pmodel", "0", "current player model number in nehahra"}

Definition at line 40 of file cl_cmd.c.

{CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "pmodel", "0", "current player model number in nehahra"};

Referenced by CL_InitCommands(), and CL_SendPlayerInfo().

cl_rate

cvar_t cl_rate = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate", "20000", "connection speed"}

Definition at line 33 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate", "20000", "connection speed"};

Referenced by CL_InitCommands(), CL_SendMove(), CL_SendPlayerInfo(), M_Menu_Setup_f(), NetConn_ReceivedMessage(), and SCR_DrawNetGraph().

cl_rate_burstsize

cvar_t cl_rate_burstsize = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate_burstsize", "1024", "rate control burst size"}

Definition at line 34 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate_burstsize", "1024", "rate control burst size"};

Referenced by CL_InitCommands(), CL_SendMove(), CL_SendPlayerInfo(), and NetConn_ReceivedMessage().

cl_skin

cvar_t cl_skin = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "skin", "", "QW player skin name (example: base)"}

Definition at line 38 of file cl_cmd.c.

{CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "skin", "", "QW player skin name (example: base)"};

Referenced by CL_InitCommands().

cl_team

cvar_t cl_team = {CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "team", "none", "QW team (4 character limit, example: blue)"}

Definition at line 37 of file cl_cmd.c.

{CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "team", "none", "QW team (4 character limit, example: blue)"};

Referenced by CL_InitCommands().

cl_topcolor

cvar_t cl_topcolor = {CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "topcolor", "0", "color of your shirt"}

Definition at line 35 of file cl_cmd.c.

{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "topcolor", "0", "color of your shirt"};

Referenced by CL_Bottomcolor_c(), CL_Color_c(), CL_Color_f(), CL_InitCommands(), CL_SendPlayerInfo(), CL_SetInfo(), and M_Menu_Setup_f().

r_fixtrans_auto

cvar_t r_fixtrans_auto = {CF_CLIENT, "r_fixtrans_auto", "0", "automatically fixtrans textures (when set to 2, it also saves the fixed versions to a fixtrans directory)"}

Definition at line 42 of file cl_cmd.c.

{CF_CLIENT, "r_fixtrans_auto", "0", "automatically fixtrans textures (when set to 2, it also saves the fixed versions to a fixtrans directory)"};

Referenced by CL_InitCommands(), and loadimagepixelsbgra().

rcon_secure

cvar_t rcon_secure

extern

Definition at line 90 of file console.c.

{CF_CLIENT | CF_SERVER, "rcon_secure", "0", "force secure rcon authentication (1 = time based, 2 = challenge based); NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password"};

Referenced by CL_PQRcon_f(), and CL_Rcon_f().

rcon_secure_challengetimeout

cvar_t rcon_secure_challengetimeout

extern

Definition at line 91 of file console.c.

{CF_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"};

Referenced by CL_Rcon_f().