id/quake3
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
quake3/code/server/sv_rankings.c

1538 lines
36 KiB
C
Raw Normal View History

as released 2005-08-19
2005-08-19 00:00:00 +00:00
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code 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.
Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// sv_rankings.c -- global rankings interface
#include "server.h"
#include "..\rankings\1.0\gr\grapi.h"
#include "..\rankings\1.0\gr\grlog.h"
typedef struct
{
GR_CONTEXT context;
uint64_t game_id;
uint64_t match;
uint64_t player_id;
GR_PLAYER_TOKEN token;
grank_status_t grank_status;
grank_status_t final_status; // status to set after cleanup
uint32_t grank; // global rank
char name[32];
} ranked_player_t;
static int s_rankings_contexts = 0;
static qboolean s_rankings_active = qfalse;
static GR_CONTEXT s_server_context = 0;
static uint64_t s_server_match = 0;
static char* s_rankings_game_key = NULL;
static uint64_t s_rankings_game_id = 0;
static ranked_player_t* s_ranked_players = NULL;
static qboolean s_server_quitting = qfalse;
static const char s_ascii_encoding[] =
"0123456789abcdef"
"ghijklmnopqrstuv"
"wxyzABCDEFGHIJKL"
"MNOPQRSTUVWXYZ[]";
// private functions
static void SV_RankNewGameCBF( GR_NEWGAME* gr_newgame, void* cbf_arg );
static void SV_RankUserCBF( GR_LOGIN* gr_login, void* cbf_arg );
static void SV_RankJoinGameCBF( GR_JOINGAME* gr_joingame, void* cbf_arg );
static void SV_RankSendReportsCBF( GR_STATUS* gr_status, void* cbf_arg );
static void SV_RankCleanupCBF( GR_STATUS* gr_status, void* cbf_arg );
static void SV_RankCloseContext( ranked_player_t* ranked_player );
static int SV_RankAsciiEncode( char* dest, const unsigned char* src,
int src_len );
static int SV_RankAsciiDecode( unsigned char* dest, const char* src,
int src_len );
static void SV_RankEncodeGameID( uint64_t game_id, char* result,
int len );
static uint64_t SV_RankDecodePlayerID( const char* string );
static void SV_RankDecodePlayerKey( const char* string, GR_PLAYER_TOKEN key );
static char* SV_RankStatusString( GR_STATUS status );
static void SV_RankError( const char* fmt, ... );
static char SV_RankGameKey[64];
/*
================
SV_RankBegin
================
*/
void SV_RankBegin( char *gamekey )
{
GR_INIT init;
GR_STATUS status;
assert( s_rankings_contexts == 0 );
assert( !s_rankings_active );
assert( s_ranked_players == NULL );
if( sv_enableRankings->integer == 0 || Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER )
{
s_rankings_active = qfalse;
if( sv_rankingsActive->integer == 1 )
{
Cvar_Set( "sv_rankingsActive", "0" );
}
return;
}
// only allow official game key on pure servers
if( strcmp(gamekey, GR_GAMEKEY) == 0 )
{
/*
if( Cvar_VariableValue("sv_pure") != 1 )
{
Cvar_Set( "sv_enableRankings", "0" );
return;
}
*/
// substitute game-specific game key
switch( (int)Cvar_VariableValue("g_gametype") )
{
case GT_FFA:
gamekey = "Q3 Free For All";
break;
case GT_TOURNAMENT:
gamekey = "Q3 Tournament";
break;
case GT_TEAM:
gamekey = "Q3 Team Deathmatch";
break;
case GT_CTF:
gamekey = "Q3 Capture the Flag";
break;
case GT_1FCTF:
gamekey = "Q3 One Flag CTF";
break;
case GT_OBELISK:
gamekey = "Q3 Overload";
break;
case GT_HARVESTER:
gamekey = "Q3 Harvester";
break;
default:
break;
}
}
s_rankings_game_key = gamekey;
// initialize rankings
GRankLogLevel( GRLOG_OFF );
memset(SV_RankGameKey,0,sizeof(SV_RankGameKey));
strncpy(SV_RankGameKey,gamekey,sizeof(SV_RankGameKey)-1);
init = GRankInit( 1, SV_RankGameKey, GR_OPT_POLL, GR_OPT_END );
s_server_context = init.context;
s_rankings_contexts++;
Com_DPrintf( "SV_RankBegin(); GR_GAMEKEY is %s\n", gamekey );
Com_DPrintf( "SV_RankBegin(); s_rankings_contexts=%d\n",s_rankings_contexts );
Com_DPrintf( "SV_RankBegin(); s_server_context=%d\n",init.context );
// new game
if(!strlen(Cvar_VariableString( "sv_leagueName" )))
{
status = GRankNewGameAsync
(
s_server_context,
SV_RankNewGameCBF,
NULL,
GR_OPT_LEAGUENAME,
(void*)(Cvar_VariableString( "sv_leagueName" )),
GR_OPT_END
);
}
else
{
status = GRankNewGameAsync
(
s_server_context,
SV_RankNewGameCBF,
NULL,
GR_OPT_END
);
}
if( status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankBegin: Expected GR_STATUS_PENDING, got %s",
SV_RankStatusString( status ) );
return;
}
// logging
if( com_developer->value )
{
GRankLogLevel( GRLOG_TRACE );
}
// allocate rankings info for each player
s_ranked_players = Z_Malloc( sv_maxclients->value *
sizeof(ranked_player_t) );
memset( (void*)s_ranked_players, 0 ,sv_maxclients->value
* sizeof(ranked_player_t));
}
/*
================
SV_RankEnd
================
*/
void SV_RankEnd( void )
{
GR_STATUS status;
int i;
Com_DPrintf( "SV_RankEnd();\n" );
if( !s_rankings_active )
{
// cleanup after error during game
if( s_ranked_players != NULL )
{
for( i = 0; i < sv_maxclients->value; i++ )
{
if( s_ranked_players[i].context != 0 )
{
SV_RankCloseContext( &(s_ranked_players[i]) );
}
}
}
if( s_server_context != 0 )
{
SV_RankCloseContext( NULL );
}
return;
}
for( i = 0; i < sv_maxclients->value; i++ )
{
if( s_ranked_players[i].grank_status == QGR_STATUS_ACTIVE )
{
SV_RankUserLogout( i );
Com_DPrintf( "SV_RankEnd: SV_RankUserLogout %d\n",i );
}
}
assert( s_server_context != 0 );
// send match reports, proceed to SV_RankSendReportsCBF
status = GRankSendReportsAsync
(
s_server_context,
0,
SV_RankSendReportsCBF,
NULL,
GR_OPT_END
);
if( status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankEnd: Expected GR_STATUS_PENDING, got %s",
SV_RankStatusString( status ) );
}
s_rankings_active = qfalse;
Cvar_Set( "sv_rankingsActive", "0" );
}
/*
================
SV_RankPoll
================
*/
void SV_RankPoll( void )
{
GRankPoll();
}
/*
================
SV_RankCheckInit
================
*/
qboolean SV_RankCheckInit( void )
{
return (s_rankings_contexts > 0);
}
/*
================
SV_RankActive
================
*/
qboolean SV_RankActive( void )
{
return s_rankings_active;
}
/*
=================
SV_RankUserStatus
=================
*/
grank_status_t SV_RankUserStatus( int index )
{
if( !s_rankings_active )
{
return GR_STATUS_ERROR;
}
assert( s_ranked_players != NULL );
assert( index >= 0 );
assert( index < sv_maxclients->value );
return s_ranked_players[index].grank_status;
}
/*
================
SV_RankUserGRank
================
*/
int SV_RankUserGrank( int index )
{
if( !s_rankings_active )
{
return 0;
}
assert( s_ranked_players != NULL );
assert( index >= 0 );
assert( index < sv_maxclients->value );
return s_ranked_players[index].grank;
}
/*
================
SV_RankUserReset
================
*/
void SV_RankUserReset( int index )
{
if( !s_rankings_active )
{
return;
}
assert( s_ranked_players != NULL );
assert( index >= 0 );
assert( index < sv_maxclients->value );
switch( s_ranked_players[index].grank_status )
{
case QGR_STATUS_SPECTATOR:
case QGR_STATUS_NO_USER:
case QGR_STATUS_BAD_PASSWORD:
case QGR_STATUS_USER_EXISTS:
case QGR_STATUS_NO_MEMBERSHIP:
case QGR_STATUS_TIMEOUT:
case QGR_STATUS_ERROR:
s_ranked_players[index].grank_status = QGR_STATUS_NEW;
break;
default:
break;
}
}
/*
================
SV_RankUserSpectate
================
*/
void SV_RankUserSpectate( int index )
{
if( !s_rankings_active )
{
return;
}
assert( s_ranked_players != NULL );
assert( index >= 0 );
assert( index < sv_maxclients->value );
// GRANK_FIXME - check current status?
s_ranked_players[index].grank_status = QGR_STATUS_SPECTATOR;
}
/*
================
SV_RankUserCreate
================
*/
void SV_RankUserCreate( int index, char* username, char* password,
char* email )
{
GR_INIT init;
GR_STATUS status;
assert( index >= 0 );
assert( index < sv_maxclients->value );
assert( username != NULL );
assert( password != NULL );
assert( email != NULL );
assert( s_ranked_players );
assert( s_ranked_players[index].grank_status != QGR_STATUS_ACTIVE );
Com_DPrintf( "SV_RankUserCreate( %d, %s, \"****\", %s );\n", index,
username, email );
if( !s_rankings_active )
{
Com_DPrintf( "SV_RankUserCreate: Not ready to create\n" );
s_ranked_players[index].grank_status = QGR_STATUS_ERROR;
return;
}
if( s_ranked_players[index].grank_status == QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankUserCreate: Got Create from active player\n" );
return;
}
// get a separate context for the new user
init = GRankInit( 0, SV_RankGameKey, GR_OPT_POLL, GR_OPT_END );
s_ranked_players[index].context = init.context;
s_rankings_contexts++;
Com_DPrintf( "SV_RankUserCreate(); s_rankings_contexts=%d\n",s_rankings_contexts );
Com_DPrintf( "SV_RankUserCreate(); s_ranked_players[%d].context=%d\n",index,init.context );
// attempt to create a new account, proceed to SV_RankUserCBF
status = GRankUserCreateAsync
(
s_ranked_players[index].context,
username,
password,
email,
SV_RankUserCBF,
(void*)&s_ranked_players[index],
GR_OPT_END
);
if( status == GR_STATUS_PENDING )
{
s_ranked_players[index].grank_status = QGR_STATUS_PENDING;
s_ranked_players[index].final_status = QGR_STATUS_NEW;
}
else
{
SV_RankError( "SV_RankUserCreate: Expected GR_STATUS_PENDING, got %s",
SV_RankStatusString( status ) );
}
}
/*
================
SV_RankUserLogin
================
*/
void SV_RankUserLogin( int index, char* username, char* password )
{
GR_INIT init;
GR_STATUS status;
assert( index >= 0 );
assert( index < sv_maxclients->value );
assert( username != NULL );
assert( password != NULL );
assert( s_ranked_players );
assert( s_ranked_players[index].grank_status != QGR_STATUS_ACTIVE );
Com_DPrintf( "SV_RankUserLogin( %d, %s, \"****\" );\n", index, username );
if( !s_rankings_active )
{
Com_DPrintf( "SV_RankUserLogin: Not ready for login\n" );
s_ranked_players[index].grank_status = QGR_STATUS_ERROR;
return;
}
if( s_ranked_players[index].grank_status == QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankUserLogin: Got Login from active player\n" );
return;
}
// get a separate context for the new user
init = GRankInit( 0, SV_RankGameKey, GR_OPT_POLL, GR_OPT_END );
s_ranked_players[index].context = init.context;
s_rankings_contexts++;
Com_DPrintf( "SV_RankUserLogin(); s_rankings_contexts=%d\n",s_rankings_contexts );
Com_DPrintf( "SV_RankUserLogin(); s_ranked_players[%d].context=%d\n",index,init.context );
// login user, proceed to SV_RankUserCBF
status = GRankUserLoginAsync
(
s_ranked_players[index].context,
username,
password,
SV_RankUserCBF,
(void*)&s_ranked_players[index],
GR_OPT_END
);
if( status == GR_STATUS_PENDING )
{
s_ranked_players[index].grank_status = QGR_STATUS_PENDING;
s_ranked_players[index].final_status = QGR_STATUS_NEW;
}
else
{
SV_RankError( "SV_RankUserLogin: Expected GR_STATUS_PENDING, got %s",
SV_RankStatusString( status ) );
}
}
/*
===================
SV_RankUserValidate
===================
*/
qboolean SV_RankUserValidate( int index, const char* player_id, const char* key, int token_len, int rank, char* name )
{
GR_INIT init;
GR_STATUS status;
qboolean rVal;
ranked_player_t* ranked_player;
int i;
assert( s_ranked_players );
assert( s_ranked_players[index].grank_status != QGR_STATUS_ACTIVE );
rVal = qfalse;
if( !s_rankings_active )
{
Com_DPrintf( "SV_RankUserValidate: Not ready to validate\n" );
s_ranked_players[index].grank_status = QGR_STATUS_ERROR;
return rVal;
}
ranked_player = &(s_ranked_players[index]);
if ( (player_id != NULL) && (key != NULL))
{
// the real player_id and key is set when SV_RankJoinGameCBF
// is called we do this so that SV_RankUserValidate
// can be shared by both server side login and client side login
// for client side logined in players
// server is creating GR_OPT_PLAYERCONTEXT
init = GRankInit( 0, SV_RankGameKey, GR_OPT_POLL, GR_OPT_END );
ranked_player->context = init.context;
s_rankings_contexts++;
Com_DPrintf( "SV_RankUserValidate(); s_rankings_contexts=%d\n",s_rankings_contexts );
Com_DPrintf( "SV_RankUserValidate(); s_ranked_players[%d].context=%d\n",index,init.context );
// uudecode player id and player token
ranked_player->player_id = SV_RankDecodePlayerID(player_id);
Com_DPrintf( "SV_RankUserValidate(); ranked_player->player_id =%u\n", (uint32_t)ranked_player->player_id );
SV_RankDecodePlayerKey(key, ranked_player->token);
// save name and check for duplicates
Q_strncpyz( ranked_player->name, name, sizeof(ranked_player->name) );
for( i = 0; i < sv_maxclients->value; i++ )
{
if( (i != index) && (s_ranked_players[i].grank_status == QGR_STATUS_ACTIVE) &&
(strcmp( s_ranked_players[i].name, name ) == 0) )
{
Com_DPrintf( "SV_RankUserValidate: Duplicate login\n" );
ranked_player->grank_status = QGR_STATUS_NO_USER;
ranked_player->final_status = QGR_STATUS_NEW;
ranked_player->grank = 0;
return qfalse;
}
}
// then validate
status = GRankPlayerValidate(
s_server_context,
ranked_player->player_id,
ranked_player->token,
token_len,
GR_OPT_PLAYERCONTEXT,
ranked_player->context,
GR_OPT_END);
}
else
{
// make server side login (bots) happy
status = GR_STATUS_OK;
}
if (status == GR_STATUS_OK)
{
ranked_player->grank_status = QGR_STATUS_ACTIVE;
ranked_player->final_status = QGR_STATUS_NEW;
ranked_player->grank = rank;
rVal = qtrue;
}
else if (status == GR_STATUS_INVALIDUSER)
{
ranked_player->grank_status = QGR_STATUS_INVALIDUSER;
ranked_player->final_status = QGR_STATUS_NEW;
ranked_player->grank = 0;
rVal = qfalse;
}
else
{
SV_RankError( "SV_RankUserValidate: Unexpected status %s",
SV_RankStatusString( status ) );
s_ranked_players[index].grank_status = QGR_STATUS_ERROR;
ranked_player->grank = 0;
}
return rVal;
}
/*
================
SV_RankUserLogout
================
*/
void SV_RankUserLogout( int index )
{
GR_STATUS status;
GR_STATUS cleanup_status;
if( !s_rankings_active )
{
return;
}
assert( index >= 0 );
assert( index < sv_maxclients->value );
assert( s_ranked_players );
if( s_ranked_players[index].context == 0 ) {
return;
}
Com_DPrintf( "SV_RankUserLogout( %d );\n", index );
// masqueraded player may not be active yet, if they fail validation,
// but still they have a context needs to be cleaned
// what matters is the s_ranked_players[index].context
// send reports, proceed to SV_RankSendReportsCBF
status = GRankSendReportsAsync
(
s_ranked_players[index].context,
0,
SV_RankSendReportsCBF,
(void*)&s_ranked_players[index],
GR_OPT_END
);
if( status == GR_STATUS_PENDING )
{
s_ranked_players[index].grank_status = QGR_STATUS_PENDING;
s_ranked_players[index].final_status = QGR_STATUS_NEW;
}
else
{
SV_RankError( "SV_RankUserLogout: Expected GR_STATUS_PENDING, got %s",
SV_RankStatusString( status ) );
cleanup_status = GRankCleanupAsync
(
s_ranked_players[index].context,
0,
SV_RankCleanupCBF,
(void*)&s_ranked_players[index],
GR_OPT_END
);
if( cleanup_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankUserLogout: Expected "
"GR_STATUS_PENDING from GRankCleanupAsync, got %s",
SV_RankStatusString( cleanup_status ) );
SV_RankCloseContext( &(s_ranked_players[index]) );
}
}
}
/*
================
SV_RankReportInt
================
*/
void SV_RankReportInt( int index1, int index2, int key, int value,
qboolean accum )
{
GR_STATUS status;
GR_CONTEXT context;
uint64_t match;
uint64_t user1;
uint64_t user2;
int opt_accum;
if( !s_rankings_active )
{
return;
}
assert( index1 >= -1 );
assert( index1 < sv_maxclients->value );
assert( index2 >= -1 );
assert( index2 < sv_maxclients->value );
assert( s_ranked_players );
// Com_DPrintf( "SV_RankReportInt( %d, %d, %d, %d, %d );\n", index1, index2,
// key, value, accum );
// get context, match, and player_id for player index1
if( index1 == -1 )
{
context = s_server_context;
match = s_server_match;
user1 = 0;
}
else
{
if( s_ranked_players[index1].grank_status != QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankReportInt: Expecting QGR_STATUS_ACTIVE"
" Got Unexpected status %d for player %d\n",
s_ranked_players[index1].grank_status, index1 );
return;
}
context = s_ranked_players[index1].context;
match = s_ranked_players[index1].match;
user1 = s_ranked_players[index1].player_id;
}
// get player_id for player index2
if( index2 == -1 )
{
user2 = 0;
}
else
{
if( s_ranked_players[index2].grank_status != QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankReportInt: Expecting QGR_STATUS_ACTIVE"
" Got Unexpected status %d for player %d\n",
s_ranked_players[index2].grank_status, index2 );
return;
}
user2 = s_ranked_players[index2].player_id;
}
opt_accum = accum ? GR_OPT_ACCUM : GR_OPT_END;
status = GRankReportInt
(
context,
match,
user1,
user2,
key,
value,
opt_accum,
GR_OPT_END
);
if( status != GR_STATUS_OK )
{
SV_RankError( "SV_RankReportInt: Unexpected status %s",
SV_RankStatusString( status ) );
}
if( user2 != 0 )
{
context = s_ranked_players[index2].context;
match = s_ranked_players[index2].match;
status = GRankReportInt
(
context,
match,
user1,
user2,
key,
value,
opt_accum,
GR_OPT_END
);
if( status != GR_STATUS_OK )
{
SV_RankError( "SV_RankReportInt: Unexpected status %s",
SV_RankStatusString( status ) );
}
}
}
/*
================
SV_RankReportStr
================
*/
void SV_RankReportStr( int index1, int index2, int key, char* value )
{
GR_STATUS status;
GR_CONTEXT context;
uint64_t match;
uint64_t user1;
uint64_t user2;
if( !s_rankings_active )
{
return;
}
assert( index1 >= -1 );
assert( index1 < sv_maxclients->value );
assert( index2 >= -1 );
assert( index2 < sv_maxclients->value );
assert( s_ranked_players );
// Com_DPrintf( "SV_RankReportStr( %d, %d, %d, \"%s\" );\n", index1, index2,
// key, value );
// get context, match, and player_id for player index1
if( index1 == -1 )
{
context = s_server_context;
match = s_server_match;
user1 = 0;
}
else
{
if( s_ranked_players[index1].grank_status != QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankReportStr: Unexpected status %d\n",
s_ranked_players[index1].grank_status );
return;
}
context = s_ranked_players[index1].context;
match = s_ranked_players[index1].match;
user1 = s_ranked_players[index1].player_id;
}
// get player_id for player index2
if( index2 == -1 )
{
user2 = 0;
}
else
{
if( s_ranked_players[index2].grank_status != QGR_STATUS_ACTIVE )
{
Com_DPrintf( "SV_RankReportStr: Unexpected status %d\n",
s_ranked_players[index2].grank_status );
return;
}
user2 = s_ranked_players[index2].player_id;
}
status = GRankReportStr
(
context,
match,
user1,
user2,
key,
value,
GR_OPT_END
);
if( status != GR_STATUS_OK )
{
SV_RankError( "SV_RankReportStr: Unexpected status %s",
SV_RankStatusString( status ) );
}
if( user2 != 0 )
{
context = s_ranked_players[index2].context;
match = s_ranked_players[index2].match;
status = GRankReportStr
(
context,
match,
user1,
user2,
key,
value,
GR_OPT_END
);
if( status != GR_STATUS_OK )
{
SV_RankError( "SV_RankReportInt: Unexpected status %s",
SV_RankStatusString( status ) );
}
}
}
/*
================
SV_RankQuit
================
*/
void SV_RankQuit( void )
{
int i;
int j = 0;
// yuck
while( s_rankings_contexts > 1 )
{
assert(s_ranked_players);
if( s_ranked_players != NULL )
{
for( i = 0; i < sv_maxclients->value; i++ )
{
// check for players that weren't yet active in SV_RankEnd
if( s_ranked_players[i].grank_status == QGR_STATUS_ACTIVE )
{
SV_RankUserLogout( i );
Com_DPrintf( "SV_RankQuit: SV_RankUserLogout %d\n",i );
}
else
{
if( s_ranked_players[i].context )
{
GR_STATUS cleanup_status;
cleanup_status = GRankCleanupAsync
(
s_ranked_players[i].context,
0,
SV_RankCleanupCBF,
(void*)&(s_ranked_players[i]),
GR_OPT_END
);
if( cleanup_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankQuit: Expected "
"GR_STATUS_PENDING from GRankCleanupAsync, got %s",
SV_RankStatusString( cleanup_status ) );
}
}
}
}
}
SV_RankPoll();
// should've finished by now
assert( (j++) < 68 );
}
}
/*
==============================================================================
Private Functions
==============================================================================
*/
/*
=================
SV_RankNewGameCBF
=================
*/
static void SV_RankNewGameCBF( GR_NEWGAME* gr_newgame, void* cbf_arg )
{
GR_MATCH match;
int i;
assert( gr_newgame != NULL );
assert( cbf_arg == NULL );
Com_DPrintf( "SV_RankNewGameCBF( %08X, %08X );\n", gr_newgame, cbf_arg );
if( gr_newgame->status == GR_STATUS_OK )
{
char info[MAX_INFO_STRING];
char gameid[sizeof(s_ranked_players[i].game_id) * 4 / 3 + 2];
// save game id
s_rankings_game_id = gr_newgame->game_id;
// encode gameid
memset(gameid,0,sizeof(gameid));
SV_RankEncodeGameID(s_rankings_game_id,gameid,sizeof(gameid));
// set CS_GRANK rankingsGameID to pass to client
memset(info,0,sizeof(info));
Info_SetValueForKey( info, "rankingsGameKey", s_rankings_game_key );
Info_SetValueForKey( info, "rankingsGameID", gameid );
SV_SetConfigstring( CS_GRANK, info );
// initialize client status
for( i = 0; i < sv_maxclients->value; i++ )
s_ranked_players[i].grank_status = QGR_STATUS_NEW;
// start new match
match = GRankStartMatch( s_server_context );
s_server_match = match.match;
// ready to go
s_rankings_active = qtrue;
Cvar_Set( "sv_rankingsActive", "1" );
}
else if( gr_newgame->status == GR_STATUS_BADLEAGUE )
{
SV_RankError( "SV_RankNewGameCBF: Invalid League name\n" );
}
else
{
//GRank handle new game failure
// force SV_RankEnd() to run
//SV_RankEnd();
SV_RankError( "SV_RankNewGameCBF: Unexpected status %s",
SV_RankStatusString( gr_newgame->status ) );
}
}
/*
================
SV_RankUserCBF
================
*/
static void SV_RankUserCBF( GR_LOGIN* gr_login, void* cbf_arg )
{
ranked_player_t* ranked_player;
GR_STATUS join_status;
GR_STATUS cleanup_status;
assert( gr_login != NULL );
assert( cbf_arg != NULL );
Com_DPrintf( "SV_RankUserCBF( %08X, %08X );\n", gr_login, cbf_arg );
ranked_player = (ranked_player_t*)cbf_arg;
assert(ranked_player);
assert( ranked_player->context );
switch( gr_login->status )
{
case GR_STATUS_OK:
// attempt to join the game, proceed to SV_RankJoinGameCBF
join_status = GRankJoinGameAsync
(
ranked_player->context,
s_rankings_game_id,
SV_RankJoinGameCBF,
cbf_arg,
GR_OPT_END
);
if( join_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankUserCBF: Expected GR_STATUS_PENDING "
"from GRankJoinGameAsync, got %s",
SV_RankStatusString( join_status ) );
}
break;
case GR_STATUS_NOUSER:
Com_DPrintf( "SV_RankUserCBF: Got status %s\n",
SV_RankStatusString( gr_login->status ) );
ranked_player->final_status = QGR_STATUS_NO_USER;
break;
case GR_STATUS_BADPASSWORD:
Com_DPrintf( "SV_RankUserCBF: Got status %s\n",
SV_RankStatusString( gr_login->status ) );
ranked_player->final_status = QGR_STATUS_BAD_PASSWORD;
break;
case GR_STATUS_TIMEOUT:
Com_DPrintf( "SV_RankUserCBF: Got status %s\n",
SV_RankStatusString( gr_login->status ) );
ranked_player->final_status = QGR_STATUS_TIMEOUT;
break;
default:
Com_DPrintf( "SV_RankUserCBF: Unexpected status %s\n",
SV_RankStatusString( gr_login->status ) );
ranked_player->final_status = QGR_STATUS_ERROR;
break;
}
if( ranked_player->final_status != QGR_STATUS_NEW )
{
// login or create failed, so clean up before the next attempt
cleanup_status = GRankCleanupAsync
(
ranked_player->context,
0,
SV_RankCleanupCBF,
(void*)ranked_player,
GR_OPT_END
);
if( cleanup_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankUserCBF: Expected GR_STATUS_PENDING "
"from GRankCleanupAsync, got %s",
SV_RankStatusString( cleanup_status ) );
SV_RankCloseContext( ranked_player );
}
}
}
/*
================
SV_RankJoinGameCBF
================
*/
static void SV_RankJoinGameCBF( GR_JOINGAME* gr_joingame, void* cbf_arg )
{
ranked_player_t* ranked_player;
GR_MATCH match;
GR_STATUS cleanup_status;
assert( gr_joingame != NULL );
assert( cbf_arg != NULL );
Com_DPrintf( "SV_RankJoinGameCBF( %08X, %08X );\n", gr_joingame, cbf_arg );
ranked_player = (ranked_player_t*)cbf_arg;
assert( ranked_player );
assert( ranked_player->context != 0 );
if( gr_joingame->status == GR_STATUS_OK )
{
int i;
// save user id
ranked_player->player_id = gr_joingame->player_id;
memcpy(ranked_player->token,gr_joingame->token,
sizeof(GR_PLAYER_TOKEN)) ;
match = GRankStartMatch( ranked_player->context );
ranked_player->match = match.match;
ranked_player->grank = gr_joingame->rank;
// find the index and call SV_RankUserValidate
for (i=0;i<sv_maxclients->value;i++)
if ( ranked_player == &s_ranked_players[i] )
SV_RankUserValidate(i,NULL,NULL,0, gr_joingame->rank,ranked_player->name);
}
else
{
//GRand handle join game failure
SV_RankError( "SV_RankJoinGameCBF: Unexpected status %s",
SV_RankStatusString( gr_joingame->status ) );
cleanup_status = GRankCleanupAsync
(
ranked_player->context,
0,
SV_RankCleanupCBF,
cbf_arg,
GR_OPT_END
);
if( cleanup_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankJoinGameCBF: Expected "
"GR_STATUS_PENDING from GRankCleanupAsync, got %s",
SV_RankStatusString( cleanup_status ) );
SV_RankCloseContext( ranked_player );
}
}
}
/*
================
SV_RankSendReportsCBF
================
*/
static void SV_RankSendReportsCBF( GR_STATUS* status, void* cbf_arg )
{
ranked_player_t* ranked_player;
GR_CONTEXT context;
GR_STATUS cleanup_status;
assert( status != NULL );
// NULL cbf_arg means server is sending match reports
Com_DPrintf( "SV_RankSendReportsCBF( %08X, %08X );\n", status, cbf_arg );
ranked_player = (ranked_player_t*)cbf_arg;
if( ranked_player == NULL )
{
Com_DPrintf( "SV_RankSendReportsCBF: server\n" );
context = s_server_context;
}
else
{
Com_DPrintf( "SV_RankSendReportsCBF: player\n" );
context = ranked_player->context;
}
//assert( context != 0 );
if( *status != GR_STATUS_OK )
{
SV_RankError( "SV_RankSendReportsCBF: Unexpected status %s",
SV_RankStatusString( *status ) );
}
if( context == 0 )
{
Com_DPrintf( "SV_RankSendReportsCBF: WARNING: context == 0" );
SV_RankCloseContext( ranked_player );
}
else
{
cleanup_status = GRankCleanupAsync
(
context,
0,
SV_RankCleanupCBF,
cbf_arg,
GR_OPT_END
);
if( cleanup_status != GR_STATUS_PENDING )
{
SV_RankError( "SV_RankSendReportsCBF: Expected "
"GR_STATUS_PENDING from GRankCleanupAsync, got %s",
SV_RankStatusString( cleanup_status ) );
SV_RankCloseContext( ranked_player );
}
}
}
/*
================
SV_RankCleanupCBF
================
*/
static void SV_RankCleanupCBF( GR_STATUS* status, void* cbf_arg )
{
ranked_player_t* ranked_player;
ranked_player = (ranked_player_t*)cbf_arg;
assert( status != NULL );
// NULL cbf_arg means server is cleaning up
Com_DPrintf( "SV_RankCleanupCBF( %08X, %08X );\n", status, cbf_arg );
if( *status != GR_STATUS_OK )
{
SV_RankError( "SV_RankCleanupCBF: Unexpected status %s",
SV_RankStatusString( *status ) );
}
SV_RankCloseContext( ranked_player );
}
/*
================
SV_RankCloseContext
================
*/
static void SV_RankCloseContext( ranked_player_t* ranked_player )
{
if( ranked_player == NULL )
{
// server cleanup
if( s_server_context == 0 )
{
return;
}
s_server_context = 0;
s_server_match = 0;
}
else
{
// player cleanup
if( s_ranked_players == NULL )
{
return;
}
if( ranked_player->context == 0 )
{
return;
}
ranked_player->context = 0;
ranked_player->match = 0;
ranked_player->player_id = 0;
memset( ranked_player->token, 0, sizeof(GR_PLAYER_TOKEN) );
ranked_player->grank_status = ranked_player->final_status;
ranked_player->final_status = QGR_STATUS_NEW;
ranked_player->name[0] = '\0';
}
assert( s_rankings_contexts > 0 );
s_rankings_contexts--;
Com_DPrintf( "SV_RankCloseContext: s_rankings_contexts = %d\n",
s_rankings_contexts );
if( s_rankings_contexts == 0 )
{
GRankLogLevel( GRLOG_OFF );
if( s_ranked_players != NULL )
{
Z_Free( s_ranked_players );
s_ranked_players = NULL;
}
s_rankings_active = qfalse;
Cvar_Set( "sv_rankingsActive", "0" );
}
}
/*
================
SV_RankAsciiEncode
Encodes src_len bytes of binary data from the src buffer as ASCII text,
using 6 bits per character. The result string is null-terminated and
stored in the dest buffer.
The dest buffer must be at least (src_len * 4) / 3 + 2 bytes in length.
Returns the length of the result string, not including the null.
================
*/
static int SV_RankAsciiEncode( char* dest, const unsigned char* src,
int src_len )
{
unsigned char bin[3];
unsigned char txt[4];
int dest_len = 0;
int i;
int j;
int num_chars;
assert( dest != NULL );
assert( src != NULL );
for( i = 0; i < src_len; i += 3 )
{
// read three bytes of input
for( j = 0; j < 3; j++ )
{
bin[j] = (i + j < src_len) ? src[i + j] : 0;
}
// get four 6-bit values from three bytes
txt[0] = bin[0] >> 2;
txt[1] = ((bin[0] << 4) | (bin[1] >> 4)) & 63;
txt[2] = ((bin[1] << 2) | (bin[2] >> 6)) & 63;
txt[3] = bin[2] & 63;
// store ASCII encoding of 6-bit values
num_chars = (i + 2 < src_len) ? 4 : ((src_len - i) * 4) / 3 + 1;
for( j = 0; j < num_chars; j++ )
{
dest[dest_len++] = s_ascii_encoding[txt[j]];
}
}
dest[dest_len] = '\0';
return dest_len;
}
/*
================
SV_RankAsciiDecode
Decodes src_len characters of ASCII text from the src buffer, stores
the binary result in the dest buffer.
The dest buffer must be at least (src_len * 3) / 4 bytes in length.
Returns the length of the binary result, or zero for invalid input.
================
*/
static int SV_RankAsciiDecode( unsigned char* dest, const char* src,
int src_len )
{
static unsigned char s_inverse_encoding[256];
static char s_init = 0;
unsigned char bin[3];
unsigned char txt[4];
int dest_len = 0;
int i;
int j;
int num_bytes;
assert( dest != NULL );
assert( src != NULL );
if( !s_init )
{
// initialize lookup table for decoding
memset( s_inverse_encoding, 255, sizeof(s_inverse_encoding) );
for( i = 0; i < 64; i++ )
{
s_inverse_encoding[s_ascii_encoding[i]] = i;
}
s_init = 1;
}
for( i = 0; i < src_len; i += 4 )
{
// read four characters of input, decode them to 6-bit values
for( j = 0; j < 4; j++ )
{
txt[j] = (i + j < src_len) ? s_inverse_encoding[src[i + j]] : 0;
if (txt[j] == 255)
{
return 0; // invalid input character
}
}
// get three bytes from four 6-bit values
bin[0] = (txt[0] << 2) | (txt[1] >> 4);
bin[1] = (txt[1] << 4) | (txt[2] >> 2);
bin[2] = (txt[2] << 6) | txt[3];
// store binary data
num_bytes = (i + 3 < src_len) ? 3 : ((src_len - i) * 3) / 4;
for( j = 0; j < num_bytes; j++ )
{
dest[dest_len++] = bin[j];
}
}
return dest_len;
}
/*
================
SV_RankEncodeGameID
================
*/
static void SV_RankEncodeGameID( uint64_t game_id, char* result,
int len )
{
assert( result != NULL );
if( len < ( ( sizeof(game_id) * 4) / 3 + 2) )
{
Com_DPrintf( "SV_RankEncodeGameID: result buffer too small\n" );
result[0] = '\0';
}
else
{
qint64 gameid = LittleLong64(*(qint64*)&game_id);
SV_RankAsciiEncode( result, (unsigned char*)&gameid,
sizeof(qint64) );
}
}
/*
================
SV_RankDecodePlayerID
================
*/
static uint64_t SV_RankDecodePlayerID( const char* string )
{
unsigned char buffer[9];
int len;
qint64 player_id;
assert( string != NULL );
len = strlen (string) ;
Com_DPrintf( "SV_RankDecodePlayerID: string length %d\n",len );
SV_RankAsciiDecode( buffer, string, len );
player_id = LittleLong64(*(qint64*)buffer);
return *(uint64_t*)&player_id;
}
/*
================
SV_RankDecodePlayerKey
================
*/
static void SV_RankDecodePlayerKey( const char* string, GR_PLAYER_TOKEN key )
{
unsigned char buffer[1400];
int len;
assert( string != NULL );
len = strlen (string) ;
Com_DPrintf( "SV_RankDecodePlayerKey: string length %d\n",len );
memset(key,0,sizeof(GR_PLAYER_TOKEN));
memset(buffer,0,sizeof(buffer));
memcpy( key, buffer, SV_RankAsciiDecode( buffer, string, len ) );
}
/*
================
SV_RankStatusString
================
*/
static char* SV_RankStatusString( GR_STATUS status )
{
switch( status )
{
case GR_STATUS_OK: return "GR_STATUS_OK";
case GR_STATUS_ERROR: return "GR_STATUS_ERROR";
case GR_STATUS_BADPARAMS: return "GR_STATUS_BADPARAMS";
case GR_STATUS_NETWORK: return "GR_STATUS_NETWORK";
case GR_STATUS_NOUSER: return "GR_STATUS_NOUSER";
case GR_STATUS_BADPASSWORD: return "GR_STATUS_BADPASSWORD";
case GR_STATUS_BADGAME: return "GR_STATUS_BADGAME";
case GR_STATUS_PENDING: return "GR_STATUS_PENDING";
case GR_STATUS_BADDOMAIN: return "GR_STATUS_BADDOMAIN";
case GR_STATUS_DOMAINLOCK: return "GR_STATUS_DOMAINLOCK";
case GR_STATUS_TIMEOUT: return "GR_STATUS_TIMEOUT";
case GR_STATUS_INVALIDUSER: return "GR_STATUS_INVALIDUSER";
case GR_STATUS_INVALIDCONTEXT: return "GR_STATUS_INVALIDCONTEXT";
default: return "(UNKNOWN)";
}
}
/*
================
SV_RankError
================
*/
static void SV_RankError( const char* fmt, ... )
{
va_list arg_ptr;
char text[1024];
va_start( arg_ptr, fmt );
vsprintf( text, fmt, arg_ptr );
va_end( arg_ptr );
Com_DPrintf( "****************************************\n" );
Com_DPrintf( "SV_RankError: %s\n", text );
Com_DPrintf( "****************************************\n" );
s_rankings_active = qfalse;
Cvar_Set( "sv_rankingsActive", "0" );
// FIXME - attempt clean shutdown?
}
Reference in a new issue Copy permalink