You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
503 lines
8.5 KiB
503 lines
8.5 KiB
/* |
|
infostring.c - network info strings |
|
Copyright (C) 2008 Uncle Mike |
|
|
|
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 3 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. |
|
*/ |
|
|
|
#include "common.h" |
|
|
|
#define MAX_KV_SIZE 128 |
|
|
|
/* |
|
======================================================================= |
|
|
|
INFOSTRING STUFF |
|
|
|
======================================================================= |
|
*/ |
|
/* |
|
=============== |
|
Info_Print |
|
|
|
printing current key-value pair |
|
=============== |
|
*/ |
|
void Info_Print( const char *s ) |
|
{ |
|
char key[MAX_KV_SIZE]; |
|
char value[MAX_KV_SIZE]; |
|
int l, count; |
|
char *o; |
|
|
|
if( *s == '\\' ) s++; |
|
|
|
while( *s ) |
|
{ |
|
count = 0; |
|
o = key; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
|
|
l = o - key; |
|
if( l < 20 ) |
|
{ |
|
memset( o, ' ', 20 - l ); |
|
key[20] = 0; |
|
} |
|
else *o = 0; |
|
|
|
Con_Printf( "%s", key ); |
|
|
|
if( !*s ) |
|
{ |
|
Con_Printf( "(null)\n" ); |
|
return; |
|
} |
|
|
|
count = 0; |
|
o = value; |
|
s++; |
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( *s ) s++; |
|
Con_Printf( "%s\n", value ); |
|
} |
|
} |
|
|
|
/* |
|
============== |
|
Info_IsValid |
|
|
|
check infostring for potential problems |
|
============== |
|
*/ |
|
qboolean Info_IsValid( const char *s ) |
|
{ |
|
char key[MAX_KV_SIZE]; |
|
char value[MAX_KV_SIZE]; |
|
int count; |
|
char *o; |
|
|
|
if( *s == '\\' ) s++; |
|
|
|
while( *s ) |
|
{ |
|
count = 0; |
|
o = key; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( !*s ) return false; |
|
|
|
count = 0; |
|
o = value; |
|
s++; |
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( !Q_strlen( value )) |
|
return false; |
|
|
|
if( *s ) s++; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
#ifndef XASH_DEDICATED |
|
/* |
|
============== |
|
Info_WriteVars |
|
|
|
============== |
|
*/ |
|
void Info_WriteVars( file_t *f ) |
|
{ |
|
char *s = CL_Userinfo(); |
|
char pkey[MAX_SERVERINFO_STRING]; |
|
static char value[4][MAX_SERVERINFO_STRING]; // use two buffers so compares work without stomping on each other |
|
static int valueindex; |
|
convar_t *pcvar; |
|
char *o; |
|
|
|
valueindex = (valueindex + 1) % 4; |
|
if( *s == '\\' ) s++; |
|
|
|
while( 1 ) |
|
{ |
|
o = pkey; |
|
while( *s != '\\' ) |
|
{ |
|
if( !*s ) return; |
|
*o++ = *s++; |
|
} |
|
*o = 0; |
|
s++; |
|
|
|
o = value[valueindex]; |
|
|
|
while( *s != '\\' && *s ) |
|
{ |
|
if( !*s ) return; |
|
*o++ = *s++; |
|
} |
|
*o = 0; |
|
|
|
pcvar = Cvar_FindVar( pkey ); |
|
|
|
if( !pcvar && pkey[0] != '*' ) // don't store out star keys |
|
FS_Printf( f, "setinfo \"%s\" \"%s\"\n", pkey, value[valueindex] ); |
|
|
|
if( !*s ) return; |
|
s++; |
|
} |
|
} |
|
#endif // XASH_DEDICATED |
|
|
|
/* |
|
=============== |
|
Info_ValueForKey |
|
|
|
Searches the string for the given |
|
key and returns the associated value, or an empty string. |
|
=============== |
|
*/ |
|
const char *Info_ValueForKey( const char *s, const char *key ) |
|
{ |
|
char pkey[MAX_KV_SIZE]; |
|
static char value[4][MAX_KV_SIZE]; // use two buffers so compares work without stomping on each other |
|
static int valueindex; |
|
int count; |
|
char *o; |
|
|
|
valueindex = (valueindex + 1) % 4; |
|
if( *s == '\\' ) s++; |
|
|
|
while( 1 ) |
|
{ |
|
count = 0; |
|
o = pkey; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s != '\\' ) |
|
{ |
|
if( !*s ) return ""; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
|
|
*o = 0; |
|
s++; |
|
|
|
o = value[valueindex]; |
|
count = 0; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
if( !*s ) return ""; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( !Q_strcmp( key, pkey )) |
|
return value[valueindex]; |
|
if( !*s ) return ""; |
|
s++; |
|
} |
|
} |
|
|
|
qboolean Info_RemoveKey( char *s, const char *key ) |
|
{ |
|
char *start; |
|
char pkey[MAX_KV_SIZE]; |
|
char value[MAX_KV_SIZE]; |
|
int cmpsize = Q_strlen( key ); |
|
int count; |
|
char *o; |
|
|
|
if( cmpsize > ( MAX_KV_SIZE - 1 )) |
|
cmpsize = MAX_KV_SIZE - 1; |
|
|
|
if( Q_strstr( key, "\\" )) |
|
return false; |
|
|
|
while( 1 ) |
|
{ |
|
start = s; |
|
if( *s == '\\' ) s++; |
|
count = 0; |
|
o = pkey; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s != '\\' ) |
|
{ |
|
if( !*s ) return false; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
s++; |
|
|
|
count = 0; |
|
o = value; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s != '\\' && *s ) |
|
{ |
|
if( !*s ) return false; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( !Q_strncmp( key, pkey, cmpsize )) |
|
{ |
|
Q_strcpy( start, s ); // remove this part |
|
return true; |
|
} |
|
|
|
if( !*s ) return false; |
|
} |
|
} |
|
|
|
void Info_RemovePrefixedKeys( char *start, char prefix ) |
|
{ |
|
char *s, *o; |
|
char pkey[MAX_KV_SIZE]; |
|
char value[MAX_KV_SIZE]; |
|
int count; |
|
|
|
s = start; |
|
|
|
while( 1 ) |
|
{ |
|
if( *s == '\\' ) s++; |
|
|
|
count = 0; |
|
o = pkey; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s != '\\' ) |
|
{ |
|
if( !*s ) return; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
s++; |
|
|
|
count = 0; |
|
o = value; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
if( !*s ) return; |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( pkey[0] == prefix ) |
|
{ |
|
Info_RemoveKey( start, pkey ); |
|
s = start; |
|
} |
|
|
|
if( !*s ) return; |
|
} |
|
} |
|
|
|
qboolean Info_IsKeyImportant( const char *key ) |
|
{ |
|
if( key[0] == '*' ) |
|
return true; |
|
if( !Q_strcmp( key, "name" )) |
|
return true; |
|
if( !Q_strcmp( key, "model" )) |
|
return true; |
|
if( !Q_strcmp( key, "rate" )) |
|
return true; |
|
if( !Q_strcmp( key, "topcolor" )) |
|
return true; |
|
if( !Q_strcmp( key, "bottomcolor" )) |
|
return true; |
|
if( !Q_strcmp( key, "cl_updaterate" )) |
|
return true; |
|
if( !Q_strcmp( key, "cl_lw" )) |
|
return true; |
|
if( !Q_strcmp( key, "cl_lc" )) |
|
return true; |
|
if( !Q_strcmp( key, "cl_nopred" )) |
|
return true; |
|
return false; |
|
} |
|
|
|
char *Info_FindLargestKey( char *s ) |
|
{ |
|
char key[MAX_KV_SIZE]; |
|
char value[MAX_KV_SIZE]; |
|
static char largest_key[128]; |
|
int largest_size = 0; |
|
int l, count; |
|
char *o; |
|
|
|
*largest_key = 0; |
|
|
|
if( *s == '\\' ) s++; |
|
|
|
while( *s ) |
|
{ |
|
int size = 0; |
|
|
|
count = 0; |
|
o = key; |
|
|
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
|
|
l = o - key; |
|
*o = 0; |
|
size = Q_strlen( key ); |
|
|
|
if( !*s ) return largest_key; |
|
|
|
count = 0; |
|
o = value; |
|
s++; |
|
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' ) |
|
{ |
|
*o++ = *s++; |
|
count++; |
|
} |
|
*o = 0; |
|
|
|
if( *s ) s++; |
|
|
|
size += Q_strlen( value ); |
|
|
|
if(( size > largest_size ) && !Info_IsKeyImportant( key )) |
|
{ |
|
Q_strncpy( largest_key, key, sizeof( largest_key )); |
|
largest_size = size; |
|
} |
|
} |
|
|
|
return largest_key; |
|
} |
|
|
|
qboolean Info_SetValueForStarKey( char *s, const char *key, const char *value, int maxsize ) |
|
{ |
|
char new[1024], *v; |
|
int c, team; |
|
|
|
if( Q_strstr( key, "\\" ) || Q_strstr( value, "\\" )) |
|
{ |
|
MsgDev( D_ERROR, "SetValueForKey: can't use keys or values with a \\\n" ); |
|
return false; |
|
} |
|
|
|
if( Q_strstr( key, ".." ) || Q_strstr( value, ".." )) |
|
return false; |
|
|
|
if( Q_strstr( key, "\"" ) || Q_strstr( value, "\"" )) |
|
{ |
|
MsgDev( D_ERROR, "SetValueForKey: can't use keys or values with a \"\n" ); |
|
return false; |
|
} |
|
|
|
if( Q_strlen( key ) > ( MAX_KV_SIZE - 1 ) || Q_strlen( value ) > ( MAX_KV_SIZE - 1 )) |
|
{ |
|
MsgDev( D_ERROR, "SetValueForKey: keys and values must be < %i characters.\n", MAX_KV_SIZE ); |
|
return false; |
|
} |
|
|
|
Info_RemoveKey( s, key ); |
|
|
|
if( !value || !Q_strlen( value )) |
|
return true; // just clear variable |
|
|
|
Q_snprintf( new, sizeof( new ), "\\%s\\%s", key, value ); |
|
if( Q_strlen( new ) + Q_strlen( s ) > maxsize ) |
|
{ |
|
// no more room in buffer to add key/value |
|
if( Info_IsKeyImportant( key )) |
|
{ |
|
// keep removing the largest key/values until we have room |
|
char *largekey; |
|
|
|
do |
|
{ |
|
largekey = Info_FindLargestKey( s ); |
|
Info_RemoveKey( s, largekey ); |
|
} while((( Q_strlen( new ) + Q_strlen( s )) >= maxsize ) && *largekey != 0 ); |
|
|
|
if( largekey[0] == 0 ) |
|
{ |
|
// no room to add setting |
|
MsgDev( D_ERROR, "SetValueForKey: info string length exceeded\n" ); |
|
return true; // info changed, new value can't saved |
|
} |
|
} |
|
else |
|
{ |
|
// no room to add setting |
|
MsgDev( D_ERROR, "SetValueForKey: info string length exceeded\n" ); |
|
return true; // info changed, new value can't saved |
|
} |
|
} |
|
|
|
// only copy ascii values |
|
s += Q_strlen( s ); |
|
v = new; |
|
|
|
team = ( Q_stricmp( key, "team" ) == 0 ) ? true : false; |
|
|
|
while( *v ) |
|
{ |
|
c = (byte)*v++; |
|
if( team ) c = Q_tolower( c ); |
|
if( c > 13 ) *s++ = c; |
|
} |
|
*s = 0; |
|
|
|
// all done |
|
return true; |
|
} |
|
|
|
qboolean Info_SetValueForKey( char *s, const char *key, const char *value, int maxsize ) |
|
{ |
|
if( key[0] == '*' ) |
|
{ |
|
MsgDev( D_ERROR, "Can't set *keys\n" ); |
|
return false; |
|
} |
|
|
|
return Info_SetValueForStarKey( s, key, value, maxsize ); |
|
}
|
|
|