sv_rankings.c

Go to the documentation of this file.

/*
===========================================================================
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?
}

---