host_cmd.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22 #include "sv_demo.h"
  23 #include "image.h"
  24
  25 #include "prvm_cmds.h"
  26 #include "utf8lib.h"
  27
  28 // for secure rcon authentication
  29 #include "hmac.h"
  30 #include "mdfour.h"
  31 #include <time.h>
  32
  33 extern cvar_t sv_adminnick;
  34 extern cvar_t sv_status_privacy;
  35 extern cvar_t sv_status_show_qcstatus;
  36 extern cvar_t sv_namechangetimer;
  37 cvar_t rcon_password = {CVAR_CLIENT | CVAR_SERVER | CVAR_PRIVATE, "rcon_password", "", "password to authenticate rcon commands; NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"};
  38 cvar_t rcon_secure = {CVAR_CLIENT | CVAR_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"};
  39 cvar_t rcon_secure_challengetimeout = {CVAR_CLIENT, "rcon_secure_challengetimeout", "5", "challenge-based secure rcon: time out requests if no challenge came within this time interval"};
  40 cvar_t rcon_address = {CVAR_CLIENT, "rcon_address", "", "server address to send rcon commands to (when not connected to a server)"};
  41 cvar_t name = {CVAR_CLIENT | CVAR_SAVE | CVAR_USERINFO, "name", "player", "change your player name"};
  42 cvar_t topcolor = {CVAR_CLIENT | CVAR_SAVE | CVAR_USERINFO, "topcolor", "0", "change the color of your shirt"};
  43 cvar_t bottomcolor = {CVAR_CLIENT | CVAR_SAVE | CVAR_USERINFO, "bottomcolor", "0", "change the color of your pants"};
  44 cvar_t team = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "team", "none", "QW team (4 character limit, example: blue)"};
  45 cvar_t skin = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "skin", "", "QW player skin name (example: base)"};
  46 cvar_t playermodel = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "playermodel", "", "current player model in Nexuiz/Xonotic"};
  47 cvar_t playerskin = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"};
  48 cvar_t noaim = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "noaim", "1", "QW option to disable vertical autoaim"};
  49 cvar_t pmodel = {CVAR_CLIENT | CVAR_USERINFO | CVAR_SAVE, "pmodel", "0", "current player model number in nehahra"};
  50 cvar_t r_fixtrans_auto = {CVAR_CLIENT, "r_fixtrans_auto", "0", "automatically fixtrans textures (when set to 2, it also saves the fixed versions to a fixtrans directory)"};
  51
  52 //============================================================================
  53
  54 /*
  55 ======================
  56 CL_Playermodel_f
  57 ======================
  58 */
  59 // the old cl_playermodel in cl_main has been renamed to __cl_playermodel
  60 static void CL_Playermodel_f(cmd_state_t *cmd)
  61 {
  62         prvm_prog_t *prog = SVVM_prog;
  63         int i, j;
  64         char newPath[sizeof(host_client->playermodel)];
  65
  66         if (Cmd_Argc (cmd) == 1)
  67         {
  68                 if (cmd->source == src_command)
  69                 {
  70                         Con_Printf("\"playermodel\" is \"%s\"\n", playermodel.string);
  71                 }
  72                 return;
  73         }
  74
  75         if (Cmd_Argc (cmd) == 2)
  76                 strlcpy (newPath, Cmd_Argv(cmd, 1), sizeof (newPath));
  77         else
  78                 strlcpy (newPath, Cmd_Args(cmd), sizeof (newPath));
  79
  80         for (i = 0, j = 0;newPath[i];i++)
  81                 if (newPath[i] != '\r' && newPath[i] != '\n')
  82                         newPath[j++] = newPath[i];
  83         newPath[j] = 0;
  84
  85         if (cmd->source == src_command)
  86         {
  87                 Cvar_Set (&cvars_all, "_cl_playermodel", newPath);
  88                 return;
  89         }
  90
  91         /*
  92         if (host.realtime < host_client->nametime)
  93         {
  94                 SV_ClientPrintf("You can't change playermodel more than once every 5 seconds!\n");
  95                 return;
  96         }
  97
  98         host_client->nametime = host.realtime + 5;
  99         */
 100
 101         // point the string back at updateclient->name to keep it safe
 102         strlcpy (host_client->playermodel, newPath, sizeof (host_client->playermodel));
 103         PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(prog, host_client->playermodel);
 104         if (strcmp(host_client->old_model, host_client->playermodel))
 105         {
 106                 strlcpy(host_client->old_model, host_client->playermodel, sizeof(host_client->old_model));
 107                 /*// send notification to all clients
 108                 MSG_WriteByte (&sv.reliable_datagram, svc_updatepmodel);
 109                 MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
 110                 MSG_WriteString (&sv.reliable_datagram, host_client->playermodel);*/
 111         }
 112 }
 113
 114 /*
 115 ======================
 116 CL_Playerskin_f
 117 ======================
 118 */
 119 static void CL_Playerskin_f(cmd_state_t *cmd)
 120 {
 121         prvm_prog_t *prog = SVVM_prog;
 122         int i, j;
 123         char newPath[sizeof(host_client->playerskin)];
 124
 125         if (Cmd_Argc (cmd) == 1)
 126         {
 127                 if (cmd->source == src_command)
 128                 {
 129                         Con_Printf("\"playerskin\" is \"%s\"\n", playerskin.string);
 130                 }
 131                 return;
 132         }
 133
 134         if (Cmd_Argc (cmd) == 2)
 135                 strlcpy (newPath, Cmd_Argv(cmd, 1), sizeof (newPath));
 136         else
 137                 strlcpy (newPath, Cmd_Args(cmd), sizeof (newPath));
 138
 139         for (i = 0, j = 0;newPath[i];i++)
 140                 if (newPath[i] != '\r' && newPath[i] != '\n')
 141                         newPath[j++] = newPath[i];
 142         newPath[j] = 0;
 143
 144         if (cmd->source == src_command)
 145         {
 146                 Cvar_Set (&cvars_all, "_cl_playerskin", newPath);
 147                 return;
 148         }
 149
 150         /*
 151         if (host.realtime < host_client->nametime)
 152         {
 153                 SV_ClientPrintf("You can't change playermodel more than once every 5 seconds!\n");
 154                 return;
 155         }
 156
 157         host_client->nametime = host.realtime + 5;
 158         */
 159
 160         // point the string back at updateclient->name to keep it safe
 161         strlcpy (host_client->playerskin, newPath, sizeof (host_client->playerskin));
 162         PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(prog, host_client->playerskin);
 163         if (strcmp(host_client->old_skin, host_client->playerskin))
 164         {
 165                 //if (host_client->begun)
 166                 //      SV_BroadcastPrintf("%s changed skin to %s\n", host_client->name, host_client->playerskin);
 167                 strlcpy(host_client->old_skin, host_client->playerskin, sizeof(host_client->old_skin));
 168                 /*// send notification to all clients
 169                 MSG_WriteByte (&sv.reliable_datagram, svc_updatepskin);
 170                 MSG_WriteByte (&sv.reliable_datagram, host_client - svs.clients);
 171                 MSG_WriteString (&sv.reliable_datagram, host_client->playerskin);*/
 172         }
 173 }
 174
 175 /*
 176 ==================
 177 CL_Color_f
 178 ==================
 179 */
 180 cvar_t cl_color = {CVAR_READONLY | CVAR_CLIENT | CVAR_SAVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"};
 181
 182 // Ignore the callbacks so this two-to-three way synchronization doesn't cause an infinite loop.
 183 static void CL_Color_c(char *string)
 184 {
 185         char vabuf[1024];
 186
 187         Cvar_Set_NoCallback(&topcolor, va(vabuf, sizeof(vabuf), "%i", ((atoi(string) >> 4) & 15)));
 188         Cvar_Set_NoCallback(&bottomcolor, va(vabuf, sizeof(vabuf), "%i", (atoi(string) & 15)));
 189 }
 190
 191 static void CL_Topcolor_c(char *string)
 192 {
 193         char vabuf[1024];
 194
 195         Cvar_Set_NoCallback(&cl_color, va(vabuf, sizeof(vabuf), "%i", atoi(string)*16 + bottomcolor.integer));
 196 }
 197
 198 static void CL_Bottomcolor_c(char *string)
 199 {
 200         char vabuf[1024];
 201
 202         Cvar_Set_NoCallback(&cl_color, va(vabuf, sizeof(vabuf), "%i", topcolor.integer*16 + atoi(string)));
 203 }
 204
 205 static void CL_Color_f(cmd_state_t *cmd)
 206 {
 207         int top, bottom;
 208
 209         if (Cmd_Argc(cmd) == 1)
 210         {
 211                 if (cmd->source == src_command)
 212                 {
 213                         Con_Printf("\"color\" is \"%i %i\"\n", topcolor.integer, bottomcolor.integer);
 214                         Con_Print("color <0-15> [0-15]\n");
 215                 }
 216                 return;
 217         }
 218
 219         if (Cmd_Argc(cmd) == 2)
 220                 top = bottom = atoi(Cmd_Argv(cmd, 1));
 221         else
 222         {
 223                 top = atoi(Cmd_Argv(cmd, 1));
 224                 bottom = atoi(Cmd_Argv(cmd, 2));
 225         }
 226         /*
 227          * This is just a convenient way to change topcolor and bottomcolor
 228          * We can't change cl_color from here directly because topcolor and
 229          * bottomcolor may be changed separately and do not call this function.
 230          * So it has to be changed when the userinfo strings are updated, which
 231          * happens twice here. Perhaps find a cleaner way?
 232          */
 233
 234         // LadyHavoc: allowing skin colormaps 14 and 15 by commenting this out
 235         //if (top > 13)
 236         //      top = 13;
 237         //if (bottom > 13)
 238         //      bottom = 13;
 239
 240         if (cmd->source == src_command)
 241         {
 242                 Cvar_SetValueQuick(&topcolor, top);
 243                 Cvar_SetValueQuick(&bottomcolor, bottom);
 244                 return;
 245         }
 246 }
 247
 248 cvar_t rate = {CVAR_CLIENT | CVAR_SAVE | CVAR_USERINFO, "rate", "20000", "change your connection speed"};
 249 cvar_t rate_burstsize = {CVAR_CLIENT | CVAR_SAVE | CVAR_USERINFO, "rate_burstsize", "1024", "internal storage cvar for current rate control burst size (changed by rate_burstsize command)"};
 250
 251 /*
 252 ======================
 253 CL_PModel_f
 254 LadyHavoc: only supported for Nehahra, I personally think this is dumb, but Mindcrime won't listen.
 255 LadyHavoc: correction, Mindcrime will be removing pmodel in the future, but it's still stuck here for compatibility.
 256 ======================
 257 */
 258 static void CL_PModel_f(cmd_state_t *cmd)
 259 {
 260         prvm_prog_t *prog = SVVM_prog;
 261         int i;
 262
 263         if (Cmd_Argc (cmd) == 1)
 264         {
 265                 if (cmd->source == src_command)
 266                 {
 267                         Con_Printf("\"pmodel\" is \"%s\"\n", pmodel.string);
 268                 }
 269                 return;
 270         }
 271         i = atoi(Cmd_Argv(cmd, 1));
 272
 273         if (cmd->source == src_command)
 274         {
 275                 if (pmodel.integer == i)
 276                         return;
 277                 Cvar_SetValue (&cvars_all, "_cl_pmodel", i);
 278                 if (cls.state == ca_connected)
 279                         Cmd_ForwardToServer_f(cmd);
 280                 return;
 281         }
 282
 283         PRVM_serveredictfloat(host_client->edict, pmodel) = i;
 284 }
 285
 286 //===========================================================================
 287
 288 //===========================================================================
 289
 290 static void CL_SendCvar_f(cmd_state_t *cmd)
 291 {
 292         int             i;
 293         cvar_t  *c;
 294         const char *cvarname;
 295         client_t *old;
 296         char vabuf[1024];
 297
 298         if(Cmd_Argc(cmd) != 2)
 299                 return;
 300         cvarname = Cmd_Argv(cmd, 1);
 301         if (cls.state == ca_connected)
 302         {
 303                 c = Cvar_FindVar(&cvars_all, cvarname, CVAR_CLIENT | CVAR_SERVER);
 304                 // LadyHavoc: if there is no such cvar or if it is private, send a
 305                 // reply indicating that it has no value
 306                 if(!c || (c->flags & CVAR_PRIVATE))
 307                         Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s", cvarname));
 308                 else
 309                         Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s \"%s\"", c->name, c->string));
 310                 return;
 311         }
 312         if(!sv.active)// || !PRVM_serverfunction(SV_ParseClientCommand))
 313                 return;
 314
 315         old = host_client;
 316         if (cls.state != ca_dedicated)
 317                 i = 1;
 318         else
 319                 i = 0;
 320         for(;i<svs.maxclients;i++)
 321                 if(svs.clients[i].active && svs.clients[i].netconnection)
 322                 {
 323                         host_client = &svs.clients[i];
 324                         SV_ClientCommands("sendcvar %s\n", cvarname);
 325                 }
 326         host_client = old;
 327 }
 328
 329 /*
 330 =====================
 331 CL_PQRcon_f
 332
 333 ProQuake rcon support
 334 =====================
 335 */
 336 static void CL_PQRcon_f(cmd_state_t *cmd)
 337 {
 338         int n;
 339         const char *e;
 340         lhnetsocket_t *mysocket;
 341
 342         if (Cmd_Argc(cmd) == 1)
 343         {
 344                 Con_Printf("%s: Usage: %s command\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0));
 345                 return;
 346         }
 347
 348         if (!rcon_password.string || !rcon_password.string[0] || rcon_secure.integer > 0)
 349         {
 350                 Con_Printf ("You must set rcon_password before issuing an pqrcon command, and rcon_secure must be 0.\n");
 351                 return;
 352         }
 353
 354         e = strchr(rcon_password.string, ' ');
 355         n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
 356
 357         if (cls.netcon)
 358                 cls.rcon_address = cls.netcon->peeraddress;
 359         else
 360         {
 361                 if (!rcon_address.string[0])
 362                 {
 363                         Con_Printf ("You must either be connected, or set the rcon_address cvar to issue rcon commands\n");
 364                         return;
 365                 }
 366                 LHNETADDRESS_FromString(&cls.rcon_address, rcon_address.string, sv_netport.integer);
 367         }
 368         mysocket = NetConn_ChooseClientSocketForAddress(&cls.rcon_address);
 369         if (mysocket)
 370         {
 371                 sizebuf_t buf;
 372                 unsigned char bufdata[64];
 373                 buf.data = bufdata;
 374                 SZ_Clear(&buf);
 375                 MSG_WriteLong(&buf, 0);
 376                 MSG_WriteByte(&buf, CCREQ_RCON);
 377                 SZ_Write(&buf, (const unsigned char*)rcon_password.string, n);
 378                 MSG_WriteByte(&buf, 0); // terminate the (possibly partial) string
 379                 MSG_WriteString(&buf, Cmd_Args(cmd));
 380                 StoreBigLong(buf.data, NETFLAG_CTL | (buf.cursize & NETFLAG_LENGTH_MASK));
 381                 NetConn_Write(mysocket, buf.data, buf.cursize, &cls.rcon_address);
 382                 SZ_Clear(&buf);
 383         }
 384 }
 385
 386 //=============================================================================
 387
 388 // QuakeWorld commands
 389
 390 /*
 391 =====================
 392 CL_Rcon_f
 393
 394   Send the rest of the command line over as
 395   an unconnected command.
 396 =====================
 397 */
 398 static void CL_Rcon_f(cmd_state_t *cmd) // credit: taken from QuakeWorld
 399 {
 400         int i, n;
 401         const char *e;
 402         lhnetsocket_t *mysocket;
 403
 404         if (Cmd_Argc(cmd) == 1)
 405         {
 406                 Con_Printf("%s: Usage: %s command\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, 0));
 407                 return;
 408         }
 409
 410         if (!rcon_password.string || !rcon_password.string[0])
 411         {
 412                 Con_Printf ("You must set rcon_password before issuing an rcon command.\n");
 413                 return;
 414         }
 415
 416         e = strchr(rcon_password.string, ' ');
 417         n = e ? e-rcon_password.string : (int)strlen(rcon_password.string);
 418
 419         if (cls.netcon)
 420                 cls.rcon_address = cls.netcon->peeraddress;
 421         else
 422         {
 423                 if (!rcon_address.string[0])
 424                 {
 425                         Con_Printf ("You must either be connected, or set the rcon_address cvar to issue rcon commands\n");
 426                         return;
 427                 }
 428                 LHNETADDRESS_FromString(&cls.rcon_address, rcon_address.string, sv_netport.integer);
 429         }
 430         mysocket = NetConn_ChooseClientSocketForAddress(&cls.rcon_address);
 431         if (mysocket && Cmd_Args(cmd)[0])
 432         {
 433                 // simply put together the rcon packet and send it
 434                 if(Cmd_Argv(cmd, 0)[0] == 's' || rcon_secure.integer > 1)
 435                 {
 436                         if(cls.rcon_commands[cls.rcon_ringpos][0])
 437                         {
 438                                 char s[128];
 439                                 LHNETADDRESS_ToString(&cls.rcon_addresses[cls.rcon_ringpos], s, sizeof(s), true);
 440                                 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]);
 441                                 cls.rcon_commands[cls.rcon_ringpos][0] = 0;
 442                                 --cls.rcon_trying;
 443                         }
 444                         for (i = 0;i < MAX_RCONS;i++)
 445                                 if(cls.rcon_commands[i][0])
 446                                         if (!LHNETADDRESS_Compare(&cls.rcon_address, &cls.rcon_addresses[i]))
 447                                                 break;
 448                         ++cls.rcon_trying;
 449                         if(i >= MAX_RCONS)
 450                                 NetConn_WriteString(mysocket, "\377\377\377\377getchallenge", &cls.rcon_address); // otherwise we'll request the challenge later
 451                         strlcpy(cls.rcon_commands[cls.rcon_ringpos], Cmd_Args(cmd), sizeof(cls.rcon_commands[cls.rcon_ringpos]));
 452                         cls.rcon_addresses[cls.rcon_ringpos] = cls.rcon_address;
 453                         cls.rcon_timeout[cls.rcon_ringpos] = host.realtime + rcon_secure_challengetimeout.value;
 454                         cls.rcon_ringpos = (cls.rcon_ringpos + 1) % MAX_RCONS;
 455                 }
 456                 else if(rcon_secure.integer > 0)
 457                 {
 458                         char buf[1500];
 459                         char argbuf[1500];
 460                         dpsnprintf(argbuf, sizeof(argbuf), "%ld.%06d %s", (long) time(NULL), (int) (rand() % 1000000), Cmd_Args(cmd));
 461                         memcpy(buf, "\377\377\377\377srcon HMAC-MD4 TIME ", 24);
 462                         if(HMAC_MDFOUR_16BYTES((unsigned char *) (buf + 24), (unsigned char *) argbuf, (int)strlen(argbuf), (unsigned char *) rcon_password.string, n))
 463                         {
 464                                 buf[40] = ' ';
 465                                 strlcpy(buf + 41, argbuf, sizeof(buf) - 41);
 466                                 NetConn_Write(mysocket, buf, 41 + (int)strlen(buf + 41), &cls.rcon_address);
 467                         }
 468                 }
 469                 else
 470                 {
 471                         char buf[1500];
 472                         memcpy(buf, "\377\377\377\377", 4);
 473                         dpsnprintf(buf+4, sizeof(buf)-4, "rcon %.*s %s",  n, rcon_password.string, Cmd_Args(cmd));
 474                         NetConn_WriteString(mysocket, buf, &cls.rcon_address);
 475                 }
 476         }
 477 }
 478
 479 static void CL_RCon_ClearPassword_c(char *string)
 480 {
 481         // whenever rcon_secure is changed to 0, clear rcon_password for
 482         // security reasons (prevents a send-rcon-password-as-plaintext
 483         // attack based on NQ protocol session takeover and svc_stufftext)
 484         if(atoi(string) <= 0)
 485                 Cvar_SetQuick(&rcon_password, "");
 486 }
 487
 488 /*
 489 ==================
 490 CL_FullServerinfo_f
 491
 492 Sent by server when serverinfo changes
 493 ==================
 494 */
 495 // TODO: shouldn't this be a cvar instead?
 496 static void CL_FullServerinfo_f(cmd_state_t *cmd) // credit: taken from QuakeWorld
 497 {
 498         char temp[512];
 499         if (Cmd_Argc(cmd) != 2)
 500         {
 501                 Con_Printf ("usage: fullserverinfo <complete info string>\n");
 502                 return;
 503         }
 504
 505         strlcpy (cl.qw_serverinfo, Cmd_Argv(cmd, 1), sizeof(cl.qw_serverinfo));
 506         InfoString_GetValue(cl.qw_serverinfo, "teamplay", temp, sizeof(temp));
 507         cl.qw_teamplay = atoi(temp);
 508 }
 509
 510 /*
 511 ==================
 512 CL_FullInfo_f
 513
 514 Allow clients to change userinfo
 515 ==================
 516 Casey was here :)
 517 */
 518 static void CL_FullInfo_f(cmd_state_t *cmd) // credit: taken from QuakeWorld
 519 {
 520         char key[512];
 521         char value[512];
 522         const char *s;
 523
 524         if (Cmd_Argc(cmd) != 2)
 525         {
 526                 Con_Printf ("fullinfo <complete info string>\n");
 527                 return;
 528         }
 529
 530         s = Cmd_Argv(cmd, 1);
 531         if (*s == '\\')
 532                 s++;
 533         while (*s)
 534         {
 535                 size_t len = strcspn(s, "\\");
 536                 if (len >= sizeof(key)) {
 537                         len = sizeof(key) - 1;
 538                 }
 539                 strlcpy(key, s, len + 1);
 540                 s += len;
 541                 if (!*s)
 542                 {
 543                         Con_Printf ("MISSING VALUE\n");
 544                         return;
 545                 }
 546                 ++s; // Skip over backslash.
 547
 548                 len = strcspn(s, "\\");
 549                 if (len >= sizeof(value)) {
 550                         len = sizeof(value) - 1;
 551                 }
 552                 strlcpy(value, s, len + 1);
 553
 554                 CL_SetInfo(key, value, false, false, false, false);
 555
 556                 s += len;
 557                 if (!*s)
 558                 {
 559                         break;
 560                 }
 561                 ++s; // Skip over backslash.
 562         }
 563 }
 564
 565 /*
 566 ==================
 567 CL_SetInfo_f
 568
 569 Allow clients to change userinfo
 570 ==================
 571 */
 572 static void CL_SetInfo_f(cmd_state_t *cmd) // credit: taken from QuakeWorld
 573 {
 574         if (Cmd_Argc(cmd) == 1)
 575         {
 576                 InfoString_Print(cls.userinfo);
 577                 return;
 578         }
 579         if (Cmd_Argc(cmd) != 3)
 580         {
 581                 Con_Printf ("usage: setinfo [ <key> <value> ]\n");
 582                 return;
 583         }
 584         CL_SetInfo(Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), true, false, false, false);
 585 }
 586
 587 /*
 588 ====================
 589 CL_Packet_f
 590
 591 packet <destination> <contents>
 592
 593 Contents allows \n escape character
 594 ====================
 595 */
 596 static void CL_Packet_f(cmd_state_t *cmd) // credit: taken from QuakeWorld
 597 {
 598         char send[2048];
 599         int i, l;
 600         const char *in;
 601         char *out;
 602         lhnetaddress_t address;
 603         lhnetsocket_t *mysocket;
 604
 605         if (Cmd_Argc(cmd) != 3)
 606         {
 607                 Con_Printf ("packet <destination> <contents>\n");
 608                 return;
 609         }
 610
 611         if (!LHNETADDRESS_FromString (&address, Cmd_Argv(cmd, 1), sv_netport.integer))
 612         {
 613                 Con_Printf ("Bad address\n");
 614                 return;
 615         }
 616
 617         in = Cmd_Argv(cmd, 2);
 618         out = send+4;
 619         send[0] = send[1] = send[2] = send[3] = -1;
 620
 621         l = (int)strlen (in);
 622         for (i=0 ; i<l ; i++)
 623         {
 624                 if (out >= send + sizeof(send) - 1)
 625                         break;
 626                 if (in[i] == '\\' && in[i+1] == 'n')
 627                 {
 628                         *out++ = '\n';
 629                         i++;
 630                 }
 631                 else if (in[i] == '\\' && in[i+1] == '0')
 632                 {
 633                         *out++ = '\0';
 634                         i++;
 635                 }
 636                 else if (in[i] == '\\' && in[i+1] == 't')
 637                 {
 638                         *out++ = '\t';
 639                         i++;
 640                 }
 641                 else if (in[i] == '\\' && in[i+1] == 'r')
 642                 {
 643                         *out++ = '\r';
 644                         i++;
 645                 }
 646                 else if (in[i] == '\\' && in[i+1] == '"')
 647                 {
 648                         *out++ = '\"';
 649                         i++;
 650                 }
 651                 else
 652                         *out++ = in[i];
 653         }
 654
 655         mysocket = NetConn_ChooseClientSocketForAddress(&address);
 656         if (!mysocket)
 657                 mysocket = NetConn_ChooseServerSocketForAddress(&address);
 658         if (mysocket)
 659                 NetConn_Write(mysocket, send, out - send, &address);
 660 }
 661
 662 static void CL_PingPLReport_f(cmd_state_t *cmd)
 663 {
 664         char *errbyte;
 665         int i;
 666         int l = Cmd_Argc(cmd);
 667         if (l > cl.maxclients)
 668                 l = cl.maxclients;
 669         for (i = 0;i < l;i++)
 670         {
 671                 cl.scores[i].qw_ping = atoi(Cmd_Argv(cmd, 1+i*2));
 672                 cl.scores[i].qw_packetloss = strtol(Cmd_Argv(cmd, 1+i*2+1), &errbyte, 0);
 673                 if(errbyte && *errbyte == ',')
 674                         cl.scores[i].qw_movementloss = atoi(errbyte + 1);
 675                 else
 676                         cl.scores[i].qw_movementloss = 0;
 677         }
 678 }
 679
 680 //=============================================================================
 681
 682 /*
 683 ==================
 684 Host_InitCommands
 685 ==================
 686 */
 687 void Host_InitCommands (void)
 688 {
 689         dpsnprintf(cls.userinfo, sizeof(cls.userinfo), "\\name\\player\\team\\none\\topcolor\\0\\bottomcolor\\0\\rate\\10000\\msg\\1\\noaim\\1\\*ver\\dp");
 690
 691         Cvar_RegisterVariable(&name);
 692         Cvar_RegisterAlias(&name, "_cl_name");
 693         Cvar_RegisterVariable(&cl_color);
 694         Cvar_RegisterCallback(&cl_color, CL_Color_c);
 695         Cvar_RegisterVariable(&topcolor);
 696         Cvar_RegisterCallback(&topcolor, CL_Topcolor_c);
 697         Cvar_RegisterVariable(&bottomcolor);
 698         Cvar_RegisterCallback(&bottomcolor, CL_Bottomcolor_c);
 699         Cvar_RegisterVariable(&rate);
 700         Cvar_RegisterAlias(&rate, "_cl_rate");
 701         Cvar_RegisterVariable(&rate_burstsize);
 702         Cvar_RegisterAlias(&rate_burstsize, "_cl_rate_burstsize");
 703         Cvar_RegisterVariable(&pmodel);
 704         Cvar_RegisterAlias(&pmodel, "_cl_pmodel");
 705         Cvar_RegisterVariable(&playermodel);
 706         Cvar_RegisterAlias(&playermodel, "_cl_playermodel");
 707         Cvar_RegisterVariable(&playerskin);
 708         Cvar_RegisterAlias(&playerskin, "_cl_playerskin");
 709         Cvar_RegisterVariable(&rcon_password);
 710         Cvar_RegisterVariable(&rcon_address);
 711         Cvar_RegisterVariable(&rcon_secure);
 712         Cvar_RegisterCallback(&rcon_secure, CL_RCon_ClearPassword_c);
 713         Cvar_RegisterVariable(&rcon_secure_challengetimeout);
 714         Cvar_RegisterVariable(&r_fixtrans_auto);
 715         Cvar_RegisterVariable(&team);
 716         Cvar_RegisterVariable(&skin);
 717         Cvar_RegisterVariable(&noaim);
 718
 719         Cmd_AddCommand(CMD_CLIENT, "color", CL_Color_f, "change your player shirt and pants colors");
 720         Cmd_AddCommand(CMD_USERINFO, "pmodel", CL_PModel_f, "(Nehahra-only) change your player model choice");
 721         Cmd_AddCommand(CMD_USERINFO, "playermodel", CL_Playermodel_f, "change your player model");
 722         Cmd_AddCommand(CMD_USERINFO, "playerskin", CL_Playerskin_f, "change your player skin number");
 723
 724         Cmd_AddCommand(CMD_CLIENT, "sendcvar", CL_SendCvar_f, "sends the value of a cvar to the server as a sentcvar command, for use by QuakeC");
 725         Cmd_AddCommand(CMD_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");
 726         Cmd_AddCommand(CMD_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");
 727         Cmd_AddCommand(CMD_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)");
 728         Cmd_AddCommand(CMD_CLIENT, "fullinfo", CL_FullInfo_f, "allows client to modify their userinfo");
 729         Cmd_AddCommand(CMD_CLIENT, "setinfo", CL_SetInfo_f, "modifies your userinfo");
 730         Cmd_AddCommand(CMD_CLIENT, "packet", CL_Packet_f, "send a packet to the specified address:port containing a text string");
 731         Cmd_AddCommand(CMD_CLIENT, "fixtrans", Image_FixTransparentPixels_f, "change alpha-zero pixels in an image file to sensible values, and write out a new TGA (warning: SLOW)");
 732
 733         // commands that are only sent by server to client for execution
 734         Cmd_AddCommand(CMD_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)");
 735         Cmd_AddCommand(CMD_CLIENT_FROM_SERVER, "fullserverinfo", CL_FullServerinfo_f, "internal use only, sent by server to client to update client's local copy of serverinfo string");
 736 }
 737
 738 void Host_NoOperation_f(cmd_state_t *cmd)
 739 {
 740 }