sv_rankings.c File Reference

#include "server.h"
#include "..\rankings\1.0\gr\grapi.h"
#include "..\rankings\1.0\gr\grlog.h"

Include dependency graph for sv_rankings.c:

Go to the source code of this file.

Data Structures
struct	ranked_player_t
Functions
qboolean	SV_RankActive (void)
int	SV_RankAsciiDecode (unsigned char *dest, const char *src, int src_len)
int	SV_RankAsciiEncode (char *dest, const unsigned char *src, int src_len)
void	SV_RankBegin (char *gamekey)
qboolean	SV_RankCheckInit (void)
void	SV_RankCleanupCBF (GR_STATUS *gr_status, void *cbf_arg)
void	SV_RankCloseContext (ranked_player_t *ranked_player)
uint64_t	SV_RankDecodePlayerID (const char *string)
void	SV_RankDecodePlayerKey (const char *string, GR_PLAYER_TOKEN key)
void	SV_RankEncodeGameID (uint64_t game_id, char *result, int len)
void	SV_RankEnd (void)
void	SV_RankError (const char *fmt,...)
void	SV_RankJoinGameCBF (GR_JOINGAME *gr_joingame, void *cbf_arg)
void	SV_RankNewGameCBF (GR_NEWGAME *gr_newgame, void *cbf_arg)
void	SV_RankPoll (void)
void	SV_RankQuit (void)
void	SV_RankReportInt (int index1, int index2, int key, int value, qboolean accum)
void	SV_RankReportStr (int index1, int index2, int key, char *value)
void	SV_RankSendReportsCBF (GR_STATUS *gr_status, void *cbf_arg)
char *	SV_RankStatusString (GR_STATUS status)
void	SV_RankUserCBF (GR_LOGIN *gr_login, void *cbf_arg)
void	SV_RankUserCreate (int index, char *username, char *password, char *email)
int	SV_RankUserGrank (int index)
void	SV_RankUserLogin (int index, char *username, char *password)
void	SV_RankUserLogout (int index)
void	SV_RankUserReset (int index)
void	SV_RankUserSpectate (int index)
grank_status_t	SV_RankUserStatus (int index)
qboolean	SV_RankUserValidate (int index, const char *player_id, const char *key, int token_len, int rank, char *name)
Variables
const char	s_ascii_encoding []
ranked_player_t *	s_ranked_players = NULL
qboolean	s_rankings_active = qfalse
int	s_rankings_contexts = 0
uint64_t	s_rankings_game_id = 0
char *	s_rankings_game_key = NULL
GR_CONTEXT	s_server_context = 0
uint64_t	s_server_match = 0
qboolean	s_server_quitting = qfalse
char	SV_RankGameKey [64]

---

Function Documentation

qboolean SV_RankActive (  void   )

Definition at line 283 of file sv_rankings.c. References qboolean. { return s_rankings_active; }

int SV_RankAsciiDecode (  unsigned char *  dest, const char *  src, int  src_len )  [static]

Definition at line 1372 of file sv_rankings.c. References assert, i, j, memset(), NULL, s_ascii_encoding, and src. Referenced by SV_RankDecodePlayerID(), and SV_RankDecodePlayerKey(). { 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; }

Here is the call graph for this function:

int SV_RankAsciiEncode (  char *  dest, const unsigned char *  src, int  src_len )  [static]

Definition at line 1320 of file sv_rankings.c. References assert, i, j, NULL, s_ascii_encoding, and src. Referenced by SV_RankEncodeGameID(). { 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; }

void SV_RankBegin (  char *  gamekey  )

Definition at line 79 of file sv_rankings.c. References assert, com_developer, Com_DPrintf(), ranked_player_t::context, Cvar_Set(), Cvar_VariableString(), Cvar_VariableValue(), GT_1FCTF, GT_CTF, GT_FFA, GT_HARVESTER, GT_OBELISK, GT_TEAM, GT_TOURNAMENT, init(), memset(), NULL, s_ranked_players, s_rankings_active, s_rankings_contexts, s_rankings_game_key, s_server_context, strcmp(), strlen(), strncpy(), sv_maxclients, SV_RankError(), SV_RankGameKey, SV_RankStatusString(), cvar_s::value, and Z_Malloc(). { 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)); }

Here is the call graph for this function:

qboolean SV_RankCheckInit (  void   )

Definition at line 273 of file sv_rankings.c. References qboolean, and s_rankings_contexts. { return (s_rankings_contexts > 0); }

void SV_RankCleanupCBF (  GR_STATUS *  gr_status, void *  cbf_arg )  [static]

Definition at line 1231 of file sv_rankings.c. References assert, Com_DPrintf(), NULL, SV_RankCloseContext(), SV_RankError(), and SV_RankStatusString(). { 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 ); }

Here is the call graph for this function:

void SV_RankCloseContext (  ranked_player_t *  ranked_player  )  [static]

Definition at line 1255 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, Cvar_Set(), ranked_player_t::final_status, ranked_player_t::grank_status, ranked_player_t::match, memset(), ranked_player_t::name, ranked_player_t::player_id, s_ranked_players, s_rankings_active, s_rankings_contexts, s_server_context, s_server_match, ranked_player_t::token, and Z_Free(). Referenced by SV_RankCleanupCBF(), SV_RankEnd(), SV_RankJoinGameCBF(), SV_RankSendReportsCBF(), SV_RankUserCBF(), and SV_RankUserLogout(). { 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" ); } }

Here is the call graph for this function:

uint64_t SV_RankDecodePlayerID (  const char *  string  )  [static]

Definition at line 1455 of file sv_rankings.c. References assert, buffer, Com_DPrintf(), NULL, string(), strlen(), and SV_RankAsciiDecode(). Referenced by SV_RankUserValidate(). { 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; }

Here is the call graph for this function:

void SV_RankDecodePlayerKey (  const char *  string, GR_PLAYER_TOKEN  key )  [static]

Definition at line 1475 of file sv_rankings.c. References assert, buffer, Com_DPrintf(), memcpy(), memset(), NULL, string(), strlen(), and SV_RankAsciiDecode(). Referenced by SV_RankUserValidate(). { 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 ) ); }

Here is the call graph for this function:

void SV_RankEncodeGameID (  uint64_t  game_id, char *  result, int  len )  [static]

Definition at line 1432 of file sv_rankings.c. References assert, Com_DPrintf(), NULL, and SV_RankAsciiEncode(). Referenced by SV_RankNewGameCBF(). { 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) ); } }

Here is the call graph for this function:

void SV_RankEnd (  void   )

Definition at line 199 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, Cvar_Set(), ranked_player_t::grank_status, i, NULL, s_ranked_players, s_rankings_active, s_server_context, sv_maxclients, SV_RankCloseContext(), SV_RankError(), SV_RankStatusString(), SV_RankUserLogout(), and cvar_s::value. { 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" ); }

Here is the call graph for this function:

void SV_RankError (  const char *  fmt,   ... )  [static]

Definition at line 1520 of file sv_rankings.c. References Com_DPrintf(), Cvar_Set(), s_rankings_active, va_end, va_list, va_start, and vsprintf(). Referenced by SV_RankBegin(), SV_RankCleanupCBF(), SV_RankEnd(), SV_RankJoinGameCBF(), SV_RankNewGameCBF(), SV_RankQuit(), SV_RankReportInt(), SV_RankReportStr(), SV_RankSendReportsCBF(), SV_RankUserCBF(), SV_RankUserCreate(), SV_RankUserLogin(), SV_RankUserLogout(), and SV_RankUserValidate(). { 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? }

Here is the call graph for this function:

void SV_RankJoinGameCBF (  GR_JOINGAME *  gr_joingame, void *  cbf_arg )  [static]

Definition at line 1108 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::grank, i, ranked_player_t::match, match(), memcpy(), ranked_player_t::name, NULL, ranked_player_t::player_id, s_ranked_players, sv_maxclients, SV_RankCloseContext(), SV_RankError(), SV_RankStatusString(), SV_RankUserValidate(), ranked_player_t::token, and cvar_s::value. { 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 ); } } }

Here is the call graph for this function:

void SV_RankNewGameCBF (  GR_NEWGAME *  gr_newgame, void *  cbf_arg )  [static]

Definition at line 964 of file sv_rankings.c. References assert, Com_DPrintf(), Cvar_Set(), ranked_player_t::game_id, ranked_player_t::grank_status, i, Info_SetValueForKey(), ranked_player_t::match, match(), memset(), NULL, s_ranked_players, s_rankings_active, s_rankings_game_id, s_rankings_game_key, s_server_context, s_server_match, sv_maxclients, SV_RankEncodeGameID(), SV_RankError(), SV_RankStatusString(), SV_SetConfigstring(), and cvar_s::value. { 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 ) ); } }

Here is the call graph for this function:

void SV_RankPoll (  void   )

Definition at line 263 of file sv_rankings.c. Referenced by SV_RankQuit(). { GRankPoll(); }

void SV_RankQuit (  void   )

Definition at line 901 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::grank_status, i, j, s_ranked_players, s_rankings_contexts, sv_maxclients, SV_RankError(), SV_RankPoll(), SV_RankStatusString(), SV_RankUserLogout(), and cvar_s::value. { 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 ); } }

Here is the call graph for this function:

void SV_RankReportInt (  int  index1, int  index2, int  key, int  value, qboolean  accum )

Definition at line 681 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::grank_status, ranked_player_t::match, match(), ranked_player_t::player_id, s_ranked_players, SV_RankError(), SV_RankStatusString(), and value. { 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 ) ); } } }

Here is the call graph for this function:

void SV_RankReportStr (  int  index1, int  index2, int  key, char *  value )

Definition at line 795 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::grank_status, ranked_player_t::match, match(), ranked_player_t::player_id, s_ranked_players, SV_RankError(), SV_RankStatusString(), and 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 ) ); } } }

Here is the call graph for this function:

void SV_RankSendReportsCBF (  GR_STATUS *  gr_status, void *  cbf_arg )  [static]

Definition at line 1170 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, NULL, SV_RankCloseContext(), SV_RankError(), and SV_RankStatusString(). { 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 ); } } }

Here is the call graph for this function:

char * SV_RankStatusString (  GR_STATUS  status  )  [static]

Definition at line 1494 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankCleanupCBF(), SV_RankEnd(), SV_RankJoinGameCBF(), SV_RankNewGameCBF(), SV_RankQuit(), SV_RankReportInt(), SV_RankReportStr(), SV_RankSendReportsCBF(), SV_RankUserCBF(), SV_RankUserCreate(), SV_RankUserLogin(), SV_RankUserLogout(), and SV_RankUserValidate(). { 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)"; } }

void SV_RankUserCBF (  GR_LOGIN *  gr_login, void *  cbf_arg )  [static]

Definition at line 1024 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::final_status, NULL, SV_RankCloseContext(), SV_RankError(), and SV_RankStatusString(). { 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 ); } } }

Here is the call graph for this function:

void SV_RankUserCreate (  int  index, char *  username, char *  password, char *  email )

Definition at line 383 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::final_status, ranked_player_t::grank_status, init(), NULL, s_ranked_players, s_rankings_contexts, SV_RankError(), SV_RankGameKey, and SV_RankStatusString(). { 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 ) ); } }

Here is the call graph for this function:

int SV_RankUserGrank (  int  index  )

Definition at line 312 of file sv_rankings.c. References assert, ranked_player_t::grank, NULL, and s_ranked_players. { 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; }

void SV_RankUserLogin (  int  index, char *  username, char *  password )

Definition at line 449 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::final_status, ranked_player_t::grank_status, init(), NULL, s_ranked_players, s_rankings_contexts, SV_RankError(), SV_RankGameKey, and SV_RankStatusString(). { 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 ) ); } }

Here is the call graph for this function:

void SV_RankUserLogout (  int  index  )

Definition at line 613 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::final_status, ranked_player_t::grank_status, s_ranked_players, SV_RankCloseContext(), SV_RankError(), and SV_RankStatusString(). Referenced by SV_RankEnd(), and SV_RankQuit(). { 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]) ); } } }

Here is the call graph for this function:

void SV_RankUserReset (  int  index  )

Definition at line 331 of file sv_rankings.c. References assert, ranked_player_t::grank_status, NULL, and s_ranked_players. { 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; } }

void SV_RankUserSpectate (  int  index  )

Definition at line 363 of file sv_rankings.c. References assert, ranked_player_t::grank_status, NULL, and s_ranked_players. { 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; }

grank_status_t SV_RankUserStatus (  int  index  )

Definition at line 293 of file sv_rankings.c. References assert, ranked_player_t::grank_status, NULL, and s_ranked_players. { 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; }

qboolean SV_RankUserValidate (  int  index, const char *  player_id, const char *  key, int  token_len, int  rank, char *  name )

Definition at line 511 of file sv_rankings.c. References assert, Com_DPrintf(), ranked_player_t::context, ranked_player_t::final_status, ranked_player_t::grank, ranked_player_t::grank_status, i, init(), name, ranked_player_t::name, ranked_player_t::player_id, Q_strncpyz(), qboolean, s_ranked_players, s_rankings_contexts, s_server_context, strcmp(), sv_maxclients, SV_RankDecodePlayerID(), SV_RankDecodePlayerKey(), SV_RankError(), SV_RankGameKey, SV_RankStatusString(), ranked_player_t::token, and cvar_s::value. Referenced by SV_RankJoinGameCBF(). { 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; }

Here is the call graph for this function:

---

Variable Documentation

const char s_ascii_encoding[] [static]

Initial value: "0123456789abcdef" "ghijklmnopqrstuv" "wxyzABCDEFGHIJKL" "MNOPQRSTUVWXYZ[]" Definition at line 49 of file sv_rankings.c. Referenced by SV_RankAsciiDecode(), and SV_RankAsciiEncode().

ranked_player_t* s_ranked_players = NULL [static]

Definition at line 47 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankCloseContext(), SV_RankEnd(), SV_RankJoinGameCBF(), SV_RankNewGameCBF(), SV_RankQuit(), SV_RankReportInt(), SV_RankReportStr(), SV_RankUserCreate(), SV_RankUserGrank(), SV_RankUserLogin(), SV_RankUserLogout(), SV_RankUserReset(), SV_RankUserSpectate(), SV_RankUserStatus(), and SV_RankUserValidate().

qboolean s_rankings_active = qfalse [static]

Definition at line 42 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankCloseContext(), SV_RankEnd(), SV_RankError(), and SV_RankNewGameCBF().

int s_rankings_contexts = 0 [static]

Definition at line 41 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankCheckInit(), SV_RankCloseContext(), SV_RankQuit(), SV_RankUserCreate(), SV_RankUserLogin(), and SV_RankUserValidate().

uint64_t s_rankings_game_id = 0 [static]

Definition at line 46 of file sv_rankings.c. Referenced by SV_RankNewGameCBF().

char* s_rankings_game_key = NULL [static]

Definition at line 45 of file sv_rankings.c. Referenced by SV_RankBegin(), and SV_RankNewGameCBF().

GR_CONTEXT s_server_context = 0 [static]

Definition at line 43 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankCloseContext(), SV_RankEnd(), SV_RankNewGameCBF(), and SV_RankUserValidate().

uint64_t s_server_match = 0 [static]

Definition at line 44 of file sv_rankings.c. Referenced by SV_RankCloseContext(), and SV_RankNewGameCBF().

qboolean s_server_quitting = qfalse [static]

Definition at line 48 of file sv_rankings.c.

char SV_RankGameKey[64] [static]

Definition at line 72 of file sv_rankings.c. Referenced by SV_RankBegin(), SV_RankUserCreate(), SV_RankUserLogin(), and SV_RankUserValidate().

---