mirror of
https://github.com/nzp-team/fteqw.git
synced 2024-11-23 12:22:42 +00:00
3a8ae069c4
git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@2285 fc73d0e0-1445-4013-8a0c-d673dee63da5
1754 lines
34 KiB
C
1754 lines
34 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
#include "qwsvdef.h"
|
|
|
|
#ifndef CLIENTONLY
|
|
|
|
#ifndef INVALID_SOCKET
|
|
#define INVALID_SOCKET -1
|
|
#endif
|
|
|
|
|
|
|
|
qboolean sv_allow_cheats;
|
|
|
|
int fp_messages=4, fp_persecond=4, fp_secondsdead=10;
|
|
char fp_msg[255] = { 0 };
|
|
extern cvar_t cl_warncmd;
|
|
cvar_t sv_cheats = SCVARF("sv_cheats", "0", CVAR_LATCH);
|
|
extern redirect_t sv_redirected;
|
|
|
|
extern cvar_t sv_public;
|
|
|
|
|
|
//generic helper function for naming players.
|
|
client_t *SV_GetClientForString(char *name, int *id)
|
|
{
|
|
int i;
|
|
char *s, *s2;
|
|
char nicename[80];
|
|
client_t *cl;
|
|
|
|
int first=0;
|
|
if (id && *id != -1)
|
|
first = *id;
|
|
|
|
if (!strcmp(name, "*")) //match with all
|
|
{
|
|
for (i = first, cl = svs.clients+first; i < sv.allocated_client_slots; i++, cl++)
|
|
{
|
|
if (cl->state<=cs_zombie)
|
|
continue;
|
|
|
|
*id=i+1;
|
|
return cl;
|
|
}
|
|
*id=sv.allocated_client_slots;
|
|
return NULL;
|
|
}
|
|
|
|
//check to make sure it's all an int
|
|
|
|
for (s = name; *s; s++)
|
|
{
|
|
if (*s < '0' || *s > '9')
|
|
break;
|
|
}
|
|
|
|
//we got to the end of the string and found only numbers. - it's a uid.
|
|
if (!*s)
|
|
{
|
|
int uid = Q_atoi(name);
|
|
for (i = first, cl = svs.clients; i < sv.allocated_client_slots; i++, cl++)
|
|
{
|
|
if (cl->state<=cs_zombie)
|
|
continue;
|
|
if (cl->userid == uid)
|
|
{
|
|
if (id)
|
|
*id=sv.allocated_client_slots;
|
|
return cl;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
for (i = first, cl = svs.clients+first; i < sv.allocated_client_slots; i++, cl++)
|
|
{
|
|
if (cl->state<=cs_zombie)
|
|
continue;
|
|
|
|
|
|
s = nicename;
|
|
s2 = cl->name;
|
|
while(*s2)
|
|
{
|
|
*s = *s2 & ~128;
|
|
s2++;
|
|
if (*s == '3')
|
|
*s = 'e';
|
|
else if (*s == '4')
|
|
*s = 'a';
|
|
else if (*s == '1' || *s == '7')
|
|
*s = 'l';
|
|
else if (*s >= 18 && *s < 27)
|
|
*s = *s - 18 + '0';
|
|
else if (*s >= 'A' && *s <= 'Z')
|
|
*s = *s - 'A' + 'a';
|
|
else if (*s<' ' || *s == '~')
|
|
continue;
|
|
|
|
s++;
|
|
}
|
|
*s = '\0';
|
|
|
|
if (strstr(nicename, name))
|
|
{
|
|
if (id)
|
|
*id=i+1;
|
|
return cl;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
OPERATOR CONSOLE ONLY COMMANDS
|
|
|
|
These commands can only be entered from stdin or by a remote operator datagram
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
====================
|
|
SV_SetMaster_f
|
|
|
|
Make a master server current
|
|
====================
|
|
*/
|
|
void Master_ClearAll(void);
|
|
void Master_Add(char *stringadr);
|
|
|
|
void SV_SetMaster_f (void)
|
|
{
|
|
int i;
|
|
|
|
Cvar_Set(&sv_public, "1"); //go public.
|
|
|
|
Master_ClearAll();
|
|
|
|
if (!strcmp(Cmd_Argv(1), "none"))
|
|
{
|
|
Con_Printf ("Entering no-master mode\n");
|
|
return;
|
|
}
|
|
|
|
for (i=1 ; i<Cmd_Argc() ; i++)
|
|
{
|
|
Master_Add(Cmd_Argv(i));
|
|
}
|
|
|
|
svs.last_heartbeat = -99999;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
SV_Quit_f
|
|
==================
|
|
*/
|
|
void SV_Quit_f (void)
|
|
{
|
|
SV_FinalMessage ("server shutdown\n");
|
|
Con_TPrintf (STL_SHUTTINGDOWN);
|
|
SV_Shutdown ();
|
|
Sys_Quit ();
|
|
}
|
|
|
|
/*
|
|
============
|
|
SV_Logfile_f
|
|
============
|
|
*/
|
|
void SV_Logfile_f (void)
|
|
{
|
|
extern cvar_t log_enable, log_dir, log_name;
|
|
extern char gamedirfile[];
|
|
|
|
if (log_enable.value)
|
|
{
|
|
Cvar_SetValue(&log_enable, 0);
|
|
Con_Printf("Logging disabled.\n");
|
|
}
|
|
else
|
|
{
|
|
char *d, *f;
|
|
|
|
d = gamedirfile;
|
|
if (log_dir.string[0])
|
|
d = log_dir.string;
|
|
|
|
f = "qconsole";
|
|
if (log_name.string[0])
|
|
f = log_name.string;
|
|
|
|
Con_Printf(va("Logging to %s/%s.log.\n", d, f));
|
|
Cvar_SetValue(&log_enable, 1);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
SV_Fraglogfile_f
|
|
============
|
|
*/
|
|
void SV_Fraglogfile_f (void)
|
|
{
|
|
char name[MAX_OSPATH];
|
|
int i;
|
|
|
|
if (sv_fraglogfile)
|
|
{
|
|
Con_TPrintf (STL_FLOGGINGOFF);
|
|
VFS_CLOSE (sv_fraglogfile);
|
|
sv_fraglogfile = NULL;
|
|
return;
|
|
}
|
|
|
|
// find an unused name
|
|
for (i=0 ; i<1000 ; i++)
|
|
{
|
|
sprintf (name, "frag_%i.log", i);
|
|
sv_fraglogfile = FS_OpenVFS(name, "rb", FS_GAME);
|
|
if (!sv_fraglogfile)
|
|
{ // can't read it, so create this one
|
|
sv_fraglogfile = FS_OpenVFS (name, "wb", FS_GAME);
|
|
if (!sv_fraglogfile)
|
|
i=1000; // give error
|
|
break;
|
|
}
|
|
VFS_CLOSE (sv_fraglogfile);
|
|
}
|
|
if (i==1000)
|
|
{
|
|
Con_TPrintf (STL_FLOGGINGFAILED);
|
|
sv_fraglogfile = NULL;
|
|
return;
|
|
}
|
|
|
|
Con_TPrintf (STL_FLOGGINGTO, name);
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_SetPlayer
|
|
|
|
Sets host_client and sv_player to the player with idnum Cmd_Argv(1)
|
|
==================
|
|
*/
|
|
qboolean SV_SetPlayer (void)
|
|
{
|
|
client_t *cl;
|
|
int i;
|
|
int idnum;
|
|
|
|
idnum = atoi(Cmd_Argv(1));
|
|
|
|
for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
|
|
{
|
|
if (!cl->state)
|
|
continue;
|
|
if (cl->userid == idnum)
|
|
{
|
|
host_client = cl;
|
|
sv_player = host_client->edict;
|
|
return true;
|
|
}
|
|
}
|
|
Con_TPrintf (STL_USERIDNOTONSERVER, idnum);
|
|
return false;
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_God_f
|
|
|
|
Sets client to godmode
|
|
==================
|
|
*/
|
|
void SV_God_f (void)
|
|
{
|
|
if (!sv_allow_cheats)
|
|
{
|
|
Con_TPrintf (STL_NEEDCHEATPARM);
|
|
return;
|
|
}
|
|
|
|
if (!SV_SetPlayer ())
|
|
return;
|
|
|
|
sv_player->v->flags = (int)sv_player->v->flags ^ FL_GODMODE;
|
|
if ((int)sv_player->v->flags & FL_GODMODE)
|
|
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_GODON);
|
|
else
|
|
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_GODOFF);
|
|
}
|
|
|
|
|
|
void SV_Noclip_f (void)
|
|
{
|
|
if (!sv_allow_cheats)
|
|
{
|
|
Con_TPrintf (STL_NEEDCHEATPARM);
|
|
return;
|
|
}
|
|
|
|
if (!SV_SetPlayer ())
|
|
return;
|
|
|
|
if (sv_player->v->movetype != MOVETYPE_NOCLIP)
|
|
{
|
|
sv_player->v->movetype = MOVETYPE_NOCLIP;
|
|
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_NOCLIPON);
|
|
}
|
|
else
|
|
{
|
|
sv_player->v->movetype = MOVETYPE_WALK;
|
|
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_NOCLIPOFF);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_Give_f
|
|
==================
|
|
*/
|
|
void SV_Give_f (void)
|
|
{
|
|
char *t;
|
|
int v;
|
|
|
|
if (!sv_allow_cheats)
|
|
{
|
|
Con_TPrintf (STL_NEEDCHEATPARM);
|
|
return;
|
|
}
|
|
|
|
if (!SV_SetPlayer ())
|
|
{
|
|
int oldself;
|
|
oldself = pr_global_struct->self;
|
|
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, sv_player);
|
|
Con_Printf("Result: %s\n", svprogfuncs->EvaluateDebugString(svprogfuncs, Cmd_Args()));
|
|
pr_global_struct->self = oldself;
|
|
return;
|
|
}
|
|
|
|
if (!svprogfuncs)
|
|
return;
|
|
|
|
t = Cmd_Argv(2);
|
|
v = atoi (Cmd_Argv(3));
|
|
|
|
switch (t[0])
|
|
{
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
sv_player->v->items = (int)sv_player->v->items | IT_SHOTGUN<< (t[0] - '2');
|
|
break;
|
|
|
|
case 's':
|
|
sv_player->v->ammo_shells = v;
|
|
break;
|
|
case 'n':
|
|
sv_player->v->ammo_nails = v;
|
|
break;
|
|
case 'r':
|
|
sv_player->v->ammo_rockets = v;
|
|
break;
|
|
case 'h':
|
|
sv_player->v->health = v;
|
|
break;
|
|
case 'c':
|
|
sv_player->v->ammo_cells = v;
|
|
break;
|
|
default:
|
|
{
|
|
int oldself;
|
|
oldself = pr_global_struct->self;
|
|
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, sv_player);
|
|
Con_Printf("Result: %s\n", svprogfuncs->EvaluateDebugString(svprogfuncs, Cmd_Args()));
|
|
pr_global_struct->self = oldself;
|
|
}
|
|
}
|
|
}
|
|
|
|
int ShowMapList (char *name, int flags, void *parm)
|
|
{
|
|
if (name[5] == 'b' && name[6] == '_') //skip box models
|
|
return true;
|
|
Con_Printf("%s\n", name+5);
|
|
return true;
|
|
}
|
|
void SV_MapList_f(void)
|
|
{
|
|
COM_EnumerateFiles("maps/*.bsp", ShowMapList, NULL);
|
|
}
|
|
|
|
/*
|
|
======================
|
|
SV_Map_f
|
|
|
|
handle a
|
|
map <mapname>
|
|
command from the console or progs.
|
|
======================
|
|
*/
|
|
void SV_Map_f (void)
|
|
{
|
|
char level[MAX_QPATH];
|
|
char spot[MAX_QPATH];
|
|
char expanded[MAX_QPATH];
|
|
char *nextserver;
|
|
qboolean issamelevel = false;
|
|
qboolean newunit = false;
|
|
qboolean cinematic = false;
|
|
qboolean waschangelevel = false;
|
|
qboolean wasspmap = false;
|
|
int i;
|
|
char *startspot;
|
|
|
|
if (Cmd_Argc() != 2 && Cmd_Argc() != 3)
|
|
{
|
|
Con_TPrintf (STL_MAPCOMMANDUSAGE);
|
|
return;
|
|
}
|
|
|
|
strcpy (level, Cmd_Argv(1));
|
|
startspot = ((Cmd_Argc() == 2)?NULL:Cmd_Argv(2));
|
|
|
|
waschangelevel = !strcmp(Cmd_Argv(0), "changelevel");
|
|
wasspmap = !strcmp(Cmd_Argv(0), "spmap");
|
|
|
|
nextserver = strchr(level, '+');
|
|
if (nextserver)
|
|
{
|
|
*nextserver = '\0';
|
|
nextserver++;
|
|
}
|
|
|
|
if (startspot)
|
|
{
|
|
strcpy(spot, startspot);
|
|
startspot = spot;
|
|
}
|
|
else if ((startspot = strchr(level, '$')))
|
|
{
|
|
strcpy(spot, startspot+1);
|
|
*startspot = '\0';
|
|
startspot = spot;
|
|
}
|
|
else
|
|
startspot = NULL;
|
|
|
|
if (!strcmp(level, ".")) //restart current
|
|
{
|
|
COM_StripExtension(COM_SkipPath(sv.modelname), level, sizeof(level));
|
|
issamelevel = true;
|
|
|
|
Q_strncpyz(spot, Info_ValueForKey(svs.info, "*startspot"), sizeof(spot));
|
|
startspot = spot;
|
|
}
|
|
|
|
COM_FlushFSCache();
|
|
|
|
// check to make sure the level exists
|
|
if (*level == '*')
|
|
{
|
|
memmove(level, level+1, strlen(level));
|
|
newunit=true;
|
|
}
|
|
|
|
if (strlen(level) > 4 && !strcmp(level + strlen(level)-4, ".cin"))
|
|
{
|
|
cinematic = true;
|
|
}
|
|
else
|
|
{
|
|
snprintf (expanded, sizeof(expanded), "maps/%s.bsp", level);
|
|
if (!COM_FCheckExists (expanded))
|
|
{
|
|
//doesn't exist, so try lowercase. Q3 does this.
|
|
for (i = 0; i < sizeof(level); i++)
|
|
{
|
|
if (level[i] >= 'A' && level[i] <= 'Z')
|
|
level[i] = level[i] - 'A' + 'a';
|
|
}
|
|
snprintf (expanded, sizeof(expanded), "maps/%s.bsp", level);
|
|
if (!COM_FCheckExists (expanded))
|
|
{
|
|
Con_TPrintf (STL_CANTFINDMAP, expanded);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sv.mvdrecording)
|
|
SV_MVDStop_f();
|
|
|
|
#ifndef SERVERONLY
|
|
if (!isDedicated) //otherwise, info used on map loading isn't present
|
|
Cmd_ExecuteString(va("fullserverinfo \"%s\"\n", svs.info), RESTRICT_SERVER);
|
|
|
|
if (!sv.state && cls.state)
|
|
CL_Disconnect();
|
|
#endif
|
|
|
|
SV_SaveSpawnparms (issamelevel);
|
|
|
|
if (startspot && !issamelevel && !newunit)
|
|
{
|
|
#ifdef Q2SERVER
|
|
if (ge)
|
|
{
|
|
qboolean savedinuse[MAX_CLIENTS];
|
|
for (i=0 ; i<sv.allocated_client_slots; i++)
|
|
{
|
|
savedinuse[i] = svs.clients[i].q2edict->inuse;
|
|
svs.clients[i].q2edict->inuse = false;
|
|
}
|
|
SV_SaveLevelCache(false);
|
|
for (i=0 ; i<sv.allocated_client_slots; i++)
|
|
{
|
|
svs.clients[i].q2edict->inuse = savedinuse[i];
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
SV_SaveLevelCache(false);
|
|
}
|
|
|
|
#ifdef Q3SERVER
|
|
{
|
|
cvar_t *gametype;
|
|
gametype = Cvar_Get("g_gametype", "0", CVAR_LATCH, "Q3 compatability");
|
|
if (wasspmap)
|
|
Cvar_ForceSet(gametype, "2");
|
|
else if (gametype->value == 2) //singleplayer
|
|
Cvar_ForceSet(gametype, "0");
|
|
}
|
|
#endif
|
|
|
|
for (i=0 ; i<MAX_CLIENTS ; i++) //we need to drop all q2 clients. We don't mix q1w with q2.
|
|
{
|
|
if (svs.clients[i].state>cs_connected) //so that we don't send a datagram
|
|
svs.clients[i].state=cs_connected;
|
|
}
|
|
|
|
SV_BroadcastCommand ("changing\n");
|
|
SV_SendMessagesToAll ();
|
|
|
|
#ifndef SERVERONLY
|
|
S_StopAllSounds (true);
|
|
SCR_BeginLoadingPlaque();
|
|
#endif
|
|
|
|
if (newunit || !startspot || !SV_LoadLevelCache(level, startspot, false))
|
|
{
|
|
if (waschangelevel && !startspot)
|
|
startspot = "";
|
|
SV_SpawnServer (level, startspot, false, cinematic);
|
|
}
|
|
|
|
SV_BroadcastCommand ("cmd new\n");
|
|
|
|
if (!issamelevel)
|
|
{
|
|
cvar_t *nsv;
|
|
nsv = Cvar_Get("nextserver", "", 0, "");
|
|
if (nextserver)
|
|
Cvar_Set(nsv, va("gamemap \"%s\"", nextserver));
|
|
else
|
|
Cvar_Set(nsv, "");
|
|
}
|
|
}
|
|
|
|
void SV_KillServer_f(void)
|
|
{
|
|
SV_UnspawnServer();
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_Kick_f
|
|
|
|
Kick a user off of the server
|
|
==================
|
|
*/
|
|
void SV_Kick_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTWASKICKED, cl->name);
|
|
// print directly, because the dropped client won't get the
|
|
// SV_BroadcastPrintf message
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUWEREKICKED);
|
|
SV_DropClient (cl);
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_BanIP_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
if (cl)
|
|
{
|
|
bannedips_t *nb;
|
|
nb = Z_Malloc(sizeof(bannedips_t));
|
|
nb->next = svs.bannedips;
|
|
nb->adr = cl->netchan.remote_address;
|
|
if (*Cmd_Argv(2)) //explicit blocking of all ports of a client ip
|
|
nb->adr.port = 0;
|
|
svs.bannedips = nb;
|
|
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTWASBANNED, cl->name);
|
|
// print directly, because the dropped client won't get the
|
|
// SV_BroadcastPrintf message
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUWEREBANNED);
|
|
SV_DropClient (cl);
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_BanName_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
#ifdef SVRANKING
|
|
rankstats_t rs;
|
|
#endif
|
|
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTWASBANNED, cl->name);
|
|
// print directly, because the dropped client won't get the
|
|
// SV_BroadcastPrintf message
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUWEREBANNED);
|
|
#ifdef SVRANKING
|
|
if (cl->rankid)
|
|
{
|
|
if (Rank_GetPlayerStats(cl->rankid, &rs))
|
|
{
|
|
rs.flags1 |= RANK_BANNED;
|
|
Rank_SetPlayerStats(cl->rankid, &rs);
|
|
}
|
|
}
|
|
else
|
|
Con_Printf("User is not using an account\n");
|
|
#endif
|
|
SV_DropClient (cl);
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_ForceName_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
int i;
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
Info_SetValueForKey(cl->userinfo, "name", Cmd_Argv(2), MAX_INFO_STRING);
|
|
SV_ExtractFromUserinfo(cl);
|
|
Q_strncpyz(cl->name, Cmd_Argv(2), sizeof(cl->namebuf));
|
|
i = cl - svs.clients;
|
|
MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
|
|
MSG_WriteByte (&sv.reliable_datagram, i);
|
|
MSG_WriteString (&sv.reliable_datagram, "name");
|
|
MSG_WriteString (&sv.reliable_datagram, cl->name);
|
|
|
|
return;
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_CripplePlayer_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
|
|
int persist = *Cmd_Argv(2);
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
if (!cl->iscrippled)
|
|
{
|
|
if (persist)
|
|
{
|
|
cl->iscrippled = 2;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISCRIPPLEDPERMANENTLY, cl->name);
|
|
}
|
|
else
|
|
{
|
|
cl->iscrippled = true;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISCRIPPLED, cl->name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cl->iscrippled = false;
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUARNTCRIPPLED);
|
|
}
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_Mute_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
|
|
int persist = *Cmd_Argv(2);
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
if (!cl->ismuted)
|
|
{
|
|
if (persist)
|
|
{
|
|
cl->ismuted = 2;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISMUTEDPERMANENTLY, cl->name);
|
|
}
|
|
else
|
|
{
|
|
cl->ismuted = true;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISMUTED, cl->name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cl->ismuted = false;
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUARNTMUTED);
|
|
}
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_Cuff_f (void)
|
|
{
|
|
client_t *cl;
|
|
int clnum=-1;
|
|
|
|
int persist = *Cmd_Argv(2);
|
|
|
|
while((cl = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
if (!cl->iscuffed)
|
|
{
|
|
if (persist)
|
|
{
|
|
cl->iscuffed = 2;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISCUFFEDPERMANENTLY, cl->name);
|
|
}
|
|
else
|
|
{
|
|
cl->iscuffed = true;
|
|
SV_BroadcastTPrintf (PRINT_HIGH, STL_CLIENTISCUFFED, cl->name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cl->iscuffed = false;
|
|
SV_ClientTPrintf (cl, PRINT_HIGH, STL_YOUARNTCUFFED);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (clnum == -1)
|
|
Con_TPrintf (STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
void SV_StuffToClient_f(void)
|
|
{ //with this we emulate the progs 'stuffcmds' builtin
|
|
|
|
client_t *cl;
|
|
|
|
int clnum=-1;
|
|
char *clientname = Cmd_Argv(1);
|
|
char *str;
|
|
char *c;
|
|
char *key;
|
|
|
|
Cmd_ShiftArgs(1, Cmd_ExecLevel==RESTRICT_LOCAL);
|
|
if (!strcmp(Cmd_Argv(1), "bind"))
|
|
{
|
|
key = Z_Malloc(strlen(Cmd_Argv(2))+1);
|
|
strcpy(key, Cmd_Argv(2));
|
|
Cmd_ShiftArgs(2, Cmd_ExecLevel==RESTRICT_LOCAL);
|
|
}
|
|
else
|
|
key = NULL;
|
|
str = Cmd_Args();
|
|
|
|
while(*str <= ' ') //strim leading spaces
|
|
{
|
|
if (!*str)
|
|
break;
|
|
str++;
|
|
}
|
|
|
|
//a list of safe, allowed commands. Allows any extention of this.
|
|
if (strchr(str, '\n') || strchr(str, ';') || (
|
|
strncmp(str, "setinfo", 7) &&
|
|
strncmp(str, "quit", 4) &&
|
|
strncmp(str, "gl_fb", 5) &&
|
|
strncmp(str, "r_fb", 4) &&
|
|
strncmp(str, "say", 3) && //note that the say parsing could be useful here.
|
|
strncmp(str, "echo", 4) &&
|
|
strncmp(str, "name", 4) &&
|
|
strncmp(str, "skin", 4) &&
|
|
strncmp(str, "color", 5) &&
|
|
strncmp(str, "cmd", 3) &&
|
|
strncmp(str, "fov", 3) &&
|
|
strncmp(str, "connect", 7) &&
|
|
strncmp(str, "rate", 4) &&
|
|
strncmp(str, "cd", 2) &&
|
|
strncmp(str, "easyrecord", 10) &&
|
|
strncmp(str, "leftisright", 11) &&
|
|
strncmp(str, "menu_", 5) &&
|
|
strncmp(str, "r_fullbright", 12) &&
|
|
strncmp(str, "toggleconsole", 13) &&
|
|
strncmp(str, "v_i", 3) && //idlescale vars
|
|
strncmp(str, "bf", 2) &&
|
|
strncmp(str, "+", 1) &&
|
|
strncmp(str, "-", 1) &&
|
|
strncmp(str, "impulse", 7) &&
|
|
1))
|
|
{
|
|
Con_Printf("You're not allowed to stuffcmd that\n");
|
|
|
|
if (key)
|
|
Z_Free(key);
|
|
return;
|
|
}
|
|
|
|
while((cl = SV_GetClientForString(clientname, &clnum)))
|
|
{
|
|
if (cl->protocol == SCP_QUAKE2)
|
|
ClientReliableWrite_Begin (cl, svcq2_stufftext, 3+strlen(str) + (key?strlen(key)+6:0));
|
|
else
|
|
ClientReliableWrite_Begin (cl, svc_stufftext, 3+strlen(str) + (key?strlen(key)+6:0));
|
|
|
|
if (key)
|
|
{
|
|
for (c = "bind "; *c; c++)
|
|
ClientReliableWrite_Byte (cl, *c);
|
|
|
|
for (c = key; *c; c++)
|
|
ClientReliableWrite_Byte (cl, *c);
|
|
|
|
ClientReliableWrite_Byte (cl, ' ');
|
|
}
|
|
|
|
for (c = str; *c; c++)
|
|
ClientReliableWrite_Byte (cl, *c);
|
|
ClientReliableWrite_Byte (cl, '\n');
|
|
ClientReliableWrite_Byte (cl, '\0');
|
|
}
|
|
|
|
if (key)
|
|
Z_Free(key);
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Status_f
|
|
================
|
|
*/
|
|
void SV_Status_f (void)
|
|
{
|
|
int i, j, l;
|
|
client_t *cl;
|
|
float cpu, avg, pak;
|
|
char *s;
|
|
|
|
int columns = 80;
|
|
|
|
if (sv_redirected != RD_OBLIVION && (sv_redirected != RD_NONE
|
|
#ifndef SERVERONLY
|
|
|| (vid.width < 68*8 && qrenderer != QR_NONE)
|
|
#endif
|
|
))
|
|
columns = 40;
|
|
|
|
if (!sv.state)
|
|
{
|
|
if (net_local_sv_ipadr.type != NA_LOOPBACK)
|
|
Con_Printf ("ip address : %s\n",NET_AdrToString (net_local_sv_ipadr));
|
|
|
|
Con_Printf("Server is not running\n");
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argc()>1)
|
|
columns = atoi(Cmd_Argv(1));
|
|
|
|
cpu = (svs.stats.latched_active+svs.stats.latched_idle);
|
|
if (cpu)
|
|
cpu = 100*svs.stats.latched_active/cpu;
|
|
avg = 1000*svs.stats.latched_active / STATFRAMES;
|
|
pak = (float)svs.stats.latched_packets/ STATFRAMES;
|
|
|
|
if (svs.socketip != INVALID_SOCKET && net_local_sv_ipadr.type != NA_LOOPBACK)
|
|
{
|
|
extern cvar_t pr_imitatemvdsv;
|
|
if (pr_imitatemvdsv.value)
|
|
Con_Printf ("net address : %s\n",NET_AdrToString (net_local_sv_ipadr));
|
|
else
|
|
Con_Printf ("ip address : %s\n",NET_AdrToString (net_local_sv_ipadr));
|
|
}
|
|
if (svs.socketip6 != INVALID_SOCKET && net_local_sv_ip6adr.type != NA_LOOPBACK)
|
|
Con_Printf ("ipv6 address : %s\n",NET_AdrToString (net_local_sv_ip6adr));
|
|
if (svs.socketipx != INVALID_SOCKET && net_local_sv_ipxadr.type != NA_LOOPBACK)
|
|
Con_Printf ("ipx address : %s\n",NET_AdrToString (net_local_sv_ipxadr));
|
|
#ifdef TCPCONNECT
|
|
if (svs.sockettcp != INVALID_SOCKET && net_local_sv_tcpipadr.type != NA_LOOPBACK)
|
|
Con_Printf ("tcp address : %s\n",NET_AdrToString (net_local_sv_tcpipadr));
|
|
#endif
|
|
|
|
Con_Printf ("cpu utilization : %3i%%\n",(int)cpu);
|
|
Con_Printf ("avg response time: %i ms\n",(int)avg);
|
|
Con_Printf ("packets/frame : %5.2f\n", pak); //not relevent as a limit.
|
|
|
|
// min fps lat drp
|
|
if (columns < 80)
|
|
{
|
|
// most remote clients are 40 columns
|
|
// 0123456789012345678901234567890123456789
|
|
Con_Printf ("name userid frags\n");
|
|
Con_Printf (" address rate ping drop\n");
|
|
Con_Printf (" ---------------- ---- ---- -----\n");
|
|
for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
|
|
{
|
|
if (!cl->state)
|
|
continue;
|
|
|
|
Con_Printf ("%-16.16s ", cl->name);
|
|
|
|
Con_Printf ("%6i %5i", cl->userid, (int)cl->old_frags);
|
|
if (cl->spectator)
|
|
Con_Printf(" (s)\n");
|
|
else
|
|
Con_Printf("\n");
|
|
|
|
if (cl->istobeloaded && cl->state == cs_zombie)
|
|
s = "LoadZombie";
|
|
else if (cl->protocol == SCP_BAD)
|
|
s = "bot";
|
|
else
|
|
s = NET_BaseAdrToString ( cl->netchan.remote_address);
|
|
Con_Printf (" %-16.16s", s);
|
|
if (cl->state == cs_connected)
|
|
{
|
|
Con_Printf ("CONNECTING\n");
|
|
continue;
|
|
}
|
|
if (cl->state == cs_zombie)
|
|
{
|
|
Con_Printf ("ZOMBIE\n");
|
|
continue;
|
|
}
|
|
Con_Printf ("%4i %4i %5.2f\n"
|
|
, (int)(1000*cl->netchan.frame_rate)
|
|
, (int)SV_CalcPing (cl)
|
|
, 100.0*cl->netchan.drop_count / cl->netchan.incoming_sequence);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Con_Printf ("frags userid address name rate ping drop qport dl%% dls\n");
|
|
Con_Printf ("----- ------ --------------- --------------- ---- ---- ----- ----- --- ----\n");
|
|
for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
|
|
{
|
|
if (!cl->state)
|
|
continue;
|
|
Con_Printf ("%5i %6i ", (int)cl->old_frags, cl->userid);
|
|
|
|
if (cl->istobeloaded && cl->state == cs_zombie)
|
|
s = "LoadZombie";
|
|
else if (cl->protocol == SCP_BAD)
|
|
s = "bot";
|
|
else
|
|
s = NET_BaseAdrToString ( cl->netchan.remote_address);
|
|
Con_Printf ("%s", s);
|
|
l = 16 - strlen(s);
|
|
for (j=0 ; j<l ; j++)
|
|
Con_Printf (" ");
|
|
|
|
Con_Printf ("%s", cl->name);
|
|
l = 16 - strlen(cl->name);
|
|
for (j=0 ; j<l ; j++)
|
|
Con_Printf (" ");
|
|
if (cl->state == cs_connected)
|
|
{
|
|
Con_Printf ("CONNECTING ");
|
|
}
|
|
else if (cl->state == cs_zombie)
|
|
{
|
|
Con_Printf ("ZOMBIE ");
|
|
}
|
|
else
|
|
Con_Printf ("%4i %4i %5.1f %4i"
|
|
, (int)(1000*cl->netchan.frame_rate)
|
|
, (int)SV_CalcPing (cl)
|
|
, 100.0*cl->netchan.drop_count / cl->netchan.incoming_sequence
|
|
, cl->netchan.qport);
|
|
if (cl->download)
|
|
{
|
|
Con_Printf (" %3i %4i", (cl->downloadcount*100)/cl->downloadsize, cl->downloadsize/1024);
|
|
}
|
|
if (cl->spectator)
|
|
Con_Printf(" (s)\n");
|
|
else
|
|
Con_Printf("\n");
|
|
|
|
|
|
}
|
|
}
|
|
Con_Printf ("\n");
|
|
}
|
|
|
|
/*
|
|
==================
|
|
SV_ConSay_f
|
|
==================
|
|
*/
|
|
void SV_ConSay_f(void)
|
|
{
|
|
client_t *client;
|
|
int j;
|
|
char *p;
|
|
char text[1024];
|
|
|
|
if (Cmd_Argc () < 2)
|
|
return;
|
|
|
|
Q_strcpy (text, "console: ");
|
|
p = Cmd_Args();
|
|
|
|
if (*p == '"')
|
|
{
|
|
p++;
|
|
p[Q_strlen(p)-1] = 0;
|
|
}
|
|
|
|
Q_strcat(text, p);
|
|
|
|
for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
|
|
{
|
|
if (client->state == cs_free)
|
|
continue;
|
|
SV_ClientPrintf(client, PRINT_CHAT, "%s\n", text);
|
|
}
|
|
|
|
if (sv.mvdrecording)
|
|
{
|
|
MVDWrite_Begin (dem_all, 0, strlen(text)+3);
|
|
MSG_WriteByte ((sizebuf_t*)demo.dbuf, svc_print);
|
|
MSG_WriteByte ((sizebuf_t*)demo.dbuf, PRINT_CHAT);
|
|
MSG_WriteString ((sizebuf_t*)demo.dbuf, text);
|
|
}
|
|
}
|
|
|
|
void SV_ConSayOne_f (void)
|
|
{
|
|
char text[2048];
|
|
client_t *to;
|
|
int i;
|
|
char *s;
|
|
int clnum=-1;
|
|
|
|
if (Cmd_Argc () < 3)
|
|
return;
|
|
|
|
while((to = SV_GetClientForString(Cmd_Argv(1), &clnum)))
|
|
{
|
|
Q_strcpy (text, "{console}: ");
|
|
|
|
for (i = 2; ; i++)
|
|
{
|
|
s = Cmd_Argv(i);
|
|
if (!*s)
|
|
break;
|
|
|
|
if (strlen(text) + strlen(s) + 2 >= sizeof(text)-1)
|
|
break;
|
|
strcat(text, " ");
|
|
strcat(text, s);
|
|
}
|
|
strcat(text, "\n");
|
|
SV_ClientPrintf(to, PRINT_CHAT, "%s", text);
|
|
}
|
|
if (!clnum)
|
|
Con_TPrintf(STL_USERDOESNTEXIST, Cmd_Argv(1));
|
|
}
|
|
|
|
/*
|
|
==================
|
|
SV_Heartbeat_f
|
|
==================
|
|
*/
|
|
void SV_Heartbeat_f (void)
|
|
{
|
|
svs.last_heartbeat = -9999;
|
|
}
|
|
|
|
void SV_SendServerInfoChange(char *key, const char *value)
|
|
{
|
|
if (!sv.state)
|
|
return;
|
|
#ifdef Q2SERVER
|
|
if (ge)
|
|
return; //FIXME!!!
|
|
#endif
|
|
|
|
MSG_WriteByte (&sv.reliable_datagram, svc_serverinfo);
|
|
MSG_WriteString (&sv.reliable_datagram, key);
|
|
MSG_WriteString (&sv.reliable_datagram, value);
|
|
}
|
|
|
|
/*
|
|
===========
|
|
SV_Serverinfo_f
|
|
|
|
Examine or change the serverinfo string
|
|
===========
|
|
*/
|
|
char *CopyString(char *s);
|
|
extern char *Info_KeyForNumber(char *s, int num);
|
|
void SV_Serverinfo_f (void)
|
|
{
|
|
cvar_t *var;
|
|
char value[512];
|
|
int i;
|
|
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
Con_TPrintf (STL_SERVERINFOSETTINGS);
|
|
Info_Print (svs.info);
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argc() < 3)
|
|
{
|
|
Con_TPrintf (STL_SERVERINFOSYNTAX);
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argv(1)[0] == '*')
|
|
{
|
|
if (!strcmp(Cmd_Argv(1), "*"))
|
|
if (!strcmp(Cmd_Argv(2), ""))
|
|
{ //clear it out
|
|
char *k;
|
|
for(i=0;;)
|
|
{
|
|
k = Info_KeyForNumber(svs.info, i);
|
|
if (!*k)
|
|
break; //no more.
|
|
else if (*k == '*')
|
|
i++; //can't remove * keys
|
|
else if ((var = Cvar_FindVar(k)) && var->flags&CVAR_SERVERINFO)
|
|
i++; //this one is a cvar.
|
|
else
|
|
Info_RemoveKey(svs.info, k); //we can remove this one though, so yay.
|
|
}
|
|
|
|
return;
|
|
}
|
|
Con_TPrintf (TL_STARKEYPROTECTED);
|
|
return;
|
|
}
|
|
Q_strncpyz(value, Cmd_Argv(2), sizeof(value));
|
|
value[sizeof(value)-1] = '\0';
|
|
for (i = 3; i < Cmd_Argc(); i++)
|
|
{
|
|
strncat(value, " ", sizeof(value)-1);
|
|
strncat(value, Cmd_Argv(i), sizeof(value)-1);
|
|
}
|
|
|
|
Info_SetValueForKey (svs.info, Cmd_Argv(1), value, MAX_SERVERINFO_STRING);
|
|
|
|
// if this is a cvar, change it too
|
|
var = Cvar_FindVar (Cmd_Argv(1));
|
|
if (var)
|
|
{
|
|
Cvar_Set(var, value);
|
|
/* Z_Free (var->string); // free the old value string
|
|
var->string = CopyString (value);
|
|
var->value = Q_atof (var->string);
|
|
*/ }
|
|
|
|
SV_SendServerInfoChange(Cmd_Argv(1), value);
|
|
}
|
|
|
|
|
|
/*
|
|
===========
|
|
SV_Serverinfo_f
|
|
|
|
Examine or change the serverinfo string
|
|
===========
|
|
*/
|
|
char *CopyString(char *s);
|
|
void SV_Localinfo_f (void)
|
|
{
|
|
char *old;
|
|
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
Con_TPrintf (STL_LOCALINFOSETTINGS);
|
|
Info_Print (localinfo);
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argc() != 3)
|
|
{
|
|
Con_TPrintf (STL_LOCALINFOSYNTAX);
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argv(1)[0] == '*')
|
|
{
|
|
if (!strcmp(Cmd_Argv(1), "*"))
|
|
if (!strcmp(Cmd_Argv(2), ""))
|
|
{ //clear it out
|
|
Info_RemoveNonStarKeys(localinfo);
|
|
return;
|
|
}
|
|
Con_TPrintf (TL_STARKEYPROTECTED);
|
|
return;
|
|
}
|
|
old = Info_ValueForKey(localinfo, Cmd_Argv(1));
|
|
Info_SetValueForKey (localinfo, Cmd_Argv(1), Cmd_Argv(2), MAX_LOCALINFO_STRING);
|
|
|
|
PR_LocalInfoChanged(Cmd_Argv(1), old, Cmd_Argv(2));
|
|
|
|
Con_DPrintf("Localinfo %s changed (%s -> %s)\n", Cmd_Argv(1), old, Cmd_Argv(2));
|
|
}
|
|
|
|
void SV_SaveInfos(vfsfile_t *f)
|
|
{
|
|
VFS_WRITE(f, "\n", 1);
|
|
VFS_WRITE(f, "serverinfo * \"\"\n", 16);
|
|
Info_WriteToFile(f, svs.info, "serverinfo", CVAR_SERVERINFO);
|
|
VFS_WRITE(f, "\n", 1);
|
|
VFS_WRITE(f, "localinfo * \"\"\n", 15);
|
|
Info_WriteToFile(f, localinfo, "localinfo", 0);
|
|
}
|
|
|
|
/*
|
|
void SV_ResetInfos(void)
|
|
{
|
|
// TODO: add me
|
|
}
|
|
*/
|
|
|
|
/*
|
|
===========
|
|
SV_User_f
|
|
|
|
Examine a users info strings
|
|
===========
|
|
*/
|
|
void SV_User_f (void)
|
|
{
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_TPrintf (STL_USERINFOSYNTAX);
|
|
return;
|
|
}
|
|
|
|
if (!SV_SetPlayer ())
|
|
return;
|
|
|
|
Info_Print (host_client->userinfo);
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Floodport_f
|
|
|
|
Sets the gamedir and path to a different directory.
|
|
================
|
|
*/
|
|
|
|
void SV_Floodprot_f (void)
|
|
{
|
|
int arg1, arg2, arg3;
|
|
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
if (fp_messages)
|
|
{
|
|
Con_TPrintf (STL_FLOODPROTSETTINGS,
|
|
fp_messages, fp_persecond, fp_secondsdead);
|
|
return;
|
|
}
|
|
else
|
|
Con_TPrintf (STL_FLOODPROTNOTON);
|
|
}
|
|
|
|
if (Cmd_Argc() != 4)
|
|
{
|
|
Con_TPrintf (STL_FLOODPROTSYNTAX);
|
|
return;
|
|
}
|
|
|
|
arg1 = atoi(Cmd_Argv(1));
|
|
arg2 = atoi(Cmd_Argv(2));
|
|
arg3 = atoi(Cmd_Argv(3));
|
|
|
|
if (arg1<=0 || arg2 <= 0 || arg3<=0)
|
|
{
|
|
Con_TPrintf (STL_NONEGATIVEVALUES);
|
|
return;
|
|
}
|
|
|
|
if (arg1 > 10)
|
|
{
|
|
Con_TPrintf (STL_TRACK10PLUSSMESSAGES);
|
|
return;
|
|
}
|
|
|
|
fp_messages = arg1;
|
|
fp_persecond = arg2;
|
|
fp_secondsdead = arg3;
|
|
}
|
|
|
|
void SV_Floodprotmsg_f (void)
|
|
{
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
Con_TPrintf(STL_FLOODPROTCURRENTMESSAGE, fp_msg);
|
|
return;
|
|
}
|
|
else if (Cmd_Argc() != 2)
|
|
{
|
|
Con_TPrintf(STL_FLOODPROTMESSAGESYNTAX);
|
|
return;
|
|
}
|
|
snprintf(fp_msg, sizeof(fp_msg), "%s", Cmd_Argv(1));
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
SV_Gamedir
|
|
|
|
Sets the fake *gamedir to a different directory.
|
|
================
|
|
*/
|
|
void SV_Gamedir (void)
|
|
{
|
|
char *dir;
|
|
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
Con_TPrintf (STL_CURRENTGAMEDIR, Info_ValueForKey (svs.info, "*gamedir"));
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_TPrintf (STL_SVGAMEDIRUSAGE);
|
|
return;
|
|
}
|
|
|
|
dir = Cmd_Argv(1);
|
|
|
|
if (strstr(dir, "..") || strstr(dir, "/")
|
|
|| strstr(dir, "\\") || strstr(dir, ":") )
|
|
{
|
|
Con_TPrintf (STL_GAMEDIRCANTBEPATH);
|
|
return;
|
|
}
|
|
|
|
Info_SetValueForStarKey (svs.info, "*gamedir", dir, MAX_SERVERINFO_STRING);
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Gamedir_f
|
|
|
|
Sets the gamedir and path to a different directory.
|
|
================
|
|
*/
|
|
void SV_Gamedir_f (void)
|
|
{
|
|
char *dir;
|
|
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
Con_TPrintf (STL_CURRENTGAMEDIR, com_gamedir);
|
|
return;
|
|
}
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_TPrintf (STL_GAMEDIRUSAGE);
|
|
return;
|
|
}
|
|
|
|
dir = Cmd_Argv(1);
|
|
|
|
if (strstr(dir, "..") || strstr(dir, "/")
|
|
|| strstr(dir, "\\") || strstr(dir, ":") )
|
|
{
|
|
Con_TPrintf (STL_GAMEDIRCANTBEPATH);
|
|
return;
|
|
}
|
|
|
|
COM_Gamedir (dir);
|
|
Info_SetValueForStarKey (svs.info, "*gamedir", dir, MAX_SERVERINFO_STRING);
|
|
}
|
|
|
|
|
|
extern char gamedirfile[MAX_OSPATH];
|
|
/*
|
|
================
|
|
SV_Snap
|
|
================
|
|
*/
|
|
void SV_Snap (int uid)
|
|
{
|
|
client_t *cl;
|
|
char pcxname[80];
|
|
char checkname[MAX_OSPATH];
|
|
int i;
|
|
|
|
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
|
|
{
|
|
if (!cl->state)
|
|
continue;
|
|
if (cl->userid == uid)
|
|
break;
|
|
}
|
|
if (i >= MAX_CLIENTS) {
|
|
Con_TPrintf (STL_USERDOESNTEXIST);
|
|
return;
|
|
}
|
|
if (!ISQWCLIENT(cl))
|
|
{
|
|
Con_Printf("Can only snap QW clients\n");
|
|
return;
|
|
}
|
|
|
|
sprintf(pcxname, "%d-00.pcx", uid);
|
|
|
|
sprintf(checkname, "%s/snap", gamedirfile);
|
|
Sys_mkdir(gamedirfile);
|
|
Sys_mkdir(checkname);
|
|
|
|
for (i=0 ; i<=99 ; i++)
|
|
{
|
|
pcxname[strlen(pcxname) - 6] = i/10 + '0';
|
|
pcxname[strlen(pcxname) - 5] = i%10 + '0';
|
|
sprintf (checkname, "%s/snap/%s", gamedirfile, pcxname);
|
|
if (Sys_FileTime(checkname) == -1)
|
|
break; // file doesn't exist
|
|
}
|
|
if (i==100)
|
|
{
|
|
Con_TPrintf (STL_SNAPTOOMANYFILES);
|
|
return;
|
|
}
|
|
strcpy(cl->uploadfn, checkname);
|
|
|
|
memcpy(&cl->snap_from, &net_from, sizeof(net_from));
|
|
if (sv_redirected != RD_NONE)
|
|
cl->remote_snap = true;
|
|
else
|
|
cl->remote_snap = false;
|
|
|
|
ClientReliableWrite_Begin (cl, svc_stufftext, 24);
|
|
ClientReliableWrite_String (cl, "cmd snap\n");
|
|
Con_TPrintf (STL_SNAPREQUEST, uid);
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Snap_f
|
|
================
|
|
*/
|
|
void SV_Snap_f (void)
|
|
{
|
|
int uid;
|
|
|
|
if (Cmd_Argc() != 2)
|
|
{
|
|
Con_TPrintf (STL_SNAPUSAGE);
|
|
return;
|
|
}
|
|
|
|
uid = atoi(Cmd_Argv(1));
|
|
|
|
SV_Snap(uid);
|
|
}
|
|
|
|
/*
|
|
================
|
|
SV_Snap
|
|
================
|
|
*/
|
|
void SV_SnapAll_f (void)
|
|
{
|
|
client_t *cl;
|
|
int i;
|
|
|
|
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
|
|
{
|
|
if (cl->state < cs_connected || cl->spectator)
|
|
continue;
|
|
SV_Snap(cl->userid);
|
|
}
|
|
}
|
|
|
|
float mytimer;
|
|
float lasttimer;
|
|
int ticsleft;
|
|
float timerinterval;
|
|
int timerlevel;
|
|
cvar_t *timercommand;
|
|
void SV_CheckTimer(void)
|
|
{
|
|
float ctime = Sys_DoubleTime();
|
|
// if (ctime < lasttimer) //new map? (shouldn't happen)
|
|
// mytimer = ctime+5; //trigger in a few secs
|
|
lasttimer = ctime;
|
|
|
|
if (ticsleft)
|
|
{
|
|
if (mytimer < ctime)
|
|
{
|
|
mytimer += timerinterval;
|
|
if (ticsleft > 0)
|
|
ticsleft--;
|
|
|
|
if (timercommand)
|
|
{
|
|
Cbuf_AddText(timercommand->string, timerlevel);
|
|
Cbuf_AddText("\n", timerlevel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SV_SetTimer_f(void)
|
|
{
|
|
int count;
|
|
float interval;
|
|
char *command;
|
|
|
|
if (Cmd_Argc() < 2)
|
|
{
|
|
Con_Printf("%s <count> <interval> <command>\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
count = atoi(Cmd_Argv(1));
|
|
interval = atof(Cmd_Argv(2));
|
|
|
|
if (!count && Cmd_Argc() == 2)
|
|
{
|
|
ticsleft = 0;
|
|
return;
|
|
}
|
|
|
|
if (interval <= 0 || (count <= 0 && count != -1)) //makes sure the args are right. :)
|
|
{
|
|
Con_Printf("%s count interval command\n", Cmd_Argv(0));
|
|
return;
|
|
}
|
|
|
|
Cmd_ShiftArgs(2, Cmd_ExecLevel==RESTRICT_LOCAL); //strip the two vars
|
|
command = Cmd_Args();
|
|
|
|
timercommand = Cvar_Get("sv_timer", "", CVAR_NOSET, NULL);
|
|
Cvar_ForceSet(timercommand, command);
|
|
|
|
mytimer = Sys_DoubleTime() + interval;
|
|
ticsleft = count;
|
|
timerinterval = interval;
|
|
|
|
timerlevel = Cmd_ExecLevel;
|
|
}
|
|
|
|
void SV_SendGameCommand_f(void)
|
|
{
|
|
#ifdef Q3SERVER
|
|
if (SVQ3_ConsoleCommand())
|
|
return;
|
|
#endif
|
|
|
|
#ifdef Q2SERVER
|
|
if (ge)
|
|
{
|
|
ge->ServerCommand();
|
|
}
|
|
else
|
|
#endif
|
|
Con_Printf("This command requires a Q2 sever\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
void PIN_LoadMessages(void);
|
|
void PIN_SaveMessages(void);
|
|
void PIN_DeleteOldestMessage(void);
|
|
void PIN_MakeMessage(char *from, char *msg);
|
|
|
|
void SV_Pin_Save_f(void)
|
|
{
|
|
PIN_SaveMessages();
|
|
}
|
|
void SV_Pin_Reload_f(void)
|
|
{
|
|
PIN_LoadMessages();
|
|
}
|
|
void SV_Pin_Delete_f(void)
|
|
{
|
|
PIN_DeleteOldestMessage();
|
|
}
|
|
void SV_Pin_Add_f(void)
|
|
{
|
|
PIN_MakeMessage(Cmd_Argv(1), Cmd_Argv(2));
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
SV_InitOperatorCommands
|
|
==================
|
|
*/
|
|
void SV_InitOperatorCommands (void)
|
|
{
|
|
#ifndef SERVERONLY
|
|
if (isDedicated)
|
|
#endif
|
|
{
|
|
Cmd_AddCommand ("quit", SV_Quit_f);
|
|
Cmd_AddCommand ("say", SV_ConSay_f);
|
|
Cmd_AddCommand ("sayone", SV_ConSayOne_f);
|
|
Cmd_AddCommand ("serverinfo", SV_Serverinfo_f); //commands that conflict with client commands.
|
|
Cmd_AddCommand ("user", SV_User_f);
|
|
|
|
Cmd_AddCommand ("god", SV_God_f);
|
|
Cmd_AddCommand ("give", SV_Give_f);
|
|
Cmd_AddCommand ("noclip", SV_Noclip_f);
|
|
}
|
|
|
|
Cvar_Register(&sv_cheats, "Server Permissions");
|
|
if (COM_CheckParm ("-cheats"))
|
|
{
|
|
Cvar_Set(&sv_cheats, "1");
|
|
}
|
|
|
|
Cmd_AddCommand ("logfile", SV_Logfile_f);
|
|
Cmd_AddCommand ("fraglogfile", SV_Fraglogfile_f);
|
|
|
|
Cmd_AddCommand ("snap", SV_Snap_f);
|
|
Cmd_AddCommand ("snapall", SV_SnapAll_f);
|
|
Cmd_AddCommand ("kick", SV_Kick_f);
|
|
Cmd_AddCommand ("mute", SV_Mute_f);
|
|
Cmd_AddCommand ("cuff", SV_Cuff_f);
|
|
Cmd_AddCommand ("renameclient", SV_ForceName_f);
|
|
Cmd_AddCommand ("cripple", SV_CripplePlayer_f);
|
|
Cmd_AddCommand ("banname", SV_BanName_f);
|
|
Cmd_AddCommand ("banip", SV_BanIP_f);
|
|
// Cmd_AddCommand ("ban", SV_BanName_f);
|
|
Cmd_AddCommand ("status", SV_Status_f);
|
|
|
|
Cmd_AddCommand ("sv", SV_SendGameCommand_f);
|
|
|
|
Cmd_AddCommand ("killserver", SV_KillServer_f);
|
|
Cmd_AddCommand ("map", SV_Map_f);
|
|
#ifdef Q3SERVER
|
|
Cmd_AddCommand ("spmap", SV_Map_f);
|
|
#endif
|
|
Cmd_AddCommand ("gamemap", SV_Map_f);
|
|
Cmd_AddCommand ("changelevel", SV_Map_f);
|
|
Cmd_AddCommand ("listmaps", SV_MapList_f);
|
|
Cmd_AddCommand ("setmaster", SV_SetMaster_f);
|
|
|
|
Cmd_AddCommand ("heartbeat", SV_Heartbeat_f);
|
|
|
|
Cmd_AddCommand ("localinfo", SV_Localinfo_f);
|
|
Cmd_AddCommand ("gamedir", SV_Gamedir_f);
|
|
Cmd_AddCommand ("sv_gamedir", SV_Gamedir);
|
|
Cmd_AddCommand ("floodprot", SV_Floodprot_f);
|
|
Cmd_AddCommand ("floodprotmsg", SV_Floodprotmsg_f);
|
|
Cmd_AddCommand ("sv_settimer", SV_SetTimer_f);
|
|
Cmd_AddCommand ("stuffcmd", SV_StuffToClient_f);
|
|
|
|
Cmd_AddCommand ("pin_save", SV_Pin_Save_f);
|
|
Cmd_AddCommand ("pin_reload", SV_Pin_Reload_f);
|
|
Cmd_AddCommand ("pin_delete", SV_Pin_Delete_f);
|
|
Cmd_AddCommand ("pin_add", SV_Pin_Add_f);
|
|
|
|
cl_warncmd.value = 1;
|
|
}
|
|
|
|
#endif
|