D:/Zythum/DinoKod/Client/NetClient.cpp

#include "Common/Ini.h"
#include "Common/Error.h"
#include "Common/Console.h"
#include "Common/Time.h"
#include "Common/Md5.h"
#include "Common/Command.h"
#include "Protocol/ProtocolDefs.h"
#include "Game/ClientGameManager.h"
#include "Interface/Interface.h"
#include "Mod/Mod.h"
#include "Game/ServerInfo.h"
#include "Client/GameClient.h"
#include "Client/NetClient.h"

//---------------------------------------------------------------------------------------------------------------------
KNetClient::KNetClient()
: KUDPClientSocket()
{
        m_LastStatsTime = 0;
        m_bShowStats    = false;
        m_pLocalAddr    = NULL;
        m_nLocalAddr    = 0;
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::Init()
{
        // Demarrage de  WINSOCK
        if( !KSocket::StartNetwork() )
                return false;

        if( !Create() )
                return false;

        // Initialise la socket Lobby
        if( !m_LobbySocket.Create( KNST_UDP ) )
                return false;

        const char*     pLobbyRequestHost       = g_pGame->GetpIniFile()->ReadString( "NETWORK", "LobbyRequestHost", "localhost" );
        u16                     LobbyRequestPort        = (u16)g_pGame->GetpIniFile()->ReadInt( "NETWORK", "LobbyRequestPort", 28001 );

        if( !KSocket::GetAddrByName( KStr( pLobbyRequestHost ), m_LobbyAddr ) )
        {
                KError::Error( NULL, "KNetClient::Init() : GetHostByName [%s] failed", pLobbyRequestHost );
                return false;
        }

        m_LobbyAddr.SetPort( LobbyRequestPort );

        // Récupere l'IP locale
        char            pHostName[1024];
        hostent*        pHostent;
        
        KSocket::GetHostName( pHostName, sizeof( pHostName ) );
        if( pHostent = KSocket::GetHostByName( pHostName ) )
        {
                char*   pAddrList;

                m_nLocalAddr = 0;
                while( pHostent->h_addr_list[m_nLocalAddr] )
                {
                        m_nLocalAddr ++;
                }

                if( m_nLocalAddr )
                {
                        m_pLocalAddr = new KInetAddr[m_nLocalAddr];
                        for( u32 h = 0; h < m_nLocalAddr; h ++ )
                        {
                                pAddrList = pHostent->h_addr_list[h];

                                m_pLocalAddr[h].SetInAddr( *((in_addr*)&pAddrList[h]) );
                        }
                }
        }

        // Active le broadcast
        GetSocket().EnableBroadcast( true );

        g_pGame->GetpCommand()->RegisterCommand( "getserverslist", CommandGetServersList, "Ask to lobby the servers list", this );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::Connect( KStr sHostName, u16 Port )
{
        //
        // Lance la procedure de connection au server
        //
        const char*     pServerHost;
        u16                     ServerPort;
        u32                     ServerAddr;

        g_Console << "Starting connection..." << KENDL;

        if( sHostName.GetLength() )
                pServerHost = sHostName.GetpString();
        else
                pServerHost = g_pGame->GetpIniFile()->ReadString( "NETWORK", "ServerHost", "localhost" );

        if( Port )
                ServerPort      = Port;
        else
                ServerPort      = (u16)g_pGame->GetpIniFile()->ReadInt( "NETWORK", "ServerPort", 28100 );

        // Recupere l'IP de l'host
        HOSTENT*        pHostent;

        pHostent = KSocket::GetHostByName( (char*)pServerHost );
        if( !pHostent || !pHostent->h_addr_list[0] )
        {
                KError::Error( NULL, "KNetClient::Init() : GetHostByName() failed [%s]", pServerHost );
                return false;
        }
        
        ServerAddr = *((u32*)(pHostent->h_addr_list[0]));

        // Connection au server
        if( !KUDPClientSocket::Connect( KInetAddr( ServerAddr, ServerPort ) ) )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::Disconnect()
{
        g_Console << "Disconnection..." << KENDL;

        return KUDPClientSocket::Disconnect();
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::End()
{
        g_pGame->GetpCommand()->UnregisterCommand( "getserverslist" );

        // Ferme la connection au server
        if( IsConnected() )
        {
                if( !Disconnect() )
                        return false;
        }

        if( !Close() )
                return false;
                
        if( !m_LobbySocket.Close() )
                return false;
                
        // Arret de WINSOCK
        if( !KSocket::StopNetwork() )
                return false;

        SafeDeletev( m_pLocalAddr );

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::OnConnect( KInetAddr& Addr )
{
        KUDPClientSocket::OnConnect( Addr );
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::OnDisconnect( KInetAddr& Addr )
{
        KUDPClientSocket::OnDisconnect( Addr );

        if( ((KGameClient*)g_pGame)->GetClientGameManager() )
                ((KGameClient*)g_pGame)->GetClientGameManager()->OnDisconnect();
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::Manage()
{
        if( !KUDPClientSocket::Manage() )
                return false;

        bool    bStats                  = false;
        u32             nBytesSent              = 0;
        u32             nBytesReceived  = 0;

        if( m_LastStatsTime + 1000 < g_Time.GetTime() )
        {
                bStats = true;
                m_LastStatsTime = g_Time.GetTime();
        }       
        
        if( bStats )
        {
                nBytesSent              += GetnBytesSent();
                nBytesReceived  += GetnBytesReceived();
                ResetStats();
        }

        if( bStats && m_bShowStats )
                g_Console << "SENT : " << nBytesSent << " RECEIVED : " << nBytesReceived << KENDL;

        if( !ManageLobbySocket() )
                return false;

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::OnMessage( KInetAddr& Addr, KNetMsg& Msg )
{
        KPGENERALMESSAGE        MsgType;
        KGameClient*            pGameClient = (KGameClient*)g_pGame;

        MsgType = KP_ReadGM( Msg );

        switch( MsgType )
        {
        case KPGM_GETAUTHENTICITY:
                {
                        // Envoie l'authentification
                        KNetMsg Msg2;
                        KP_WriteGM( Msg2, KPGM_AUTHENTICITY );

                        const char*             pLogin  = g_pGame->GetpIniFile()->ReadString( "LOGIN", "login", "" );
                        const char*             pPass   = g_pGame->GetpIniFile()->ReadString( "LOGIN", "password", "" );

                        KStr    sCryptedPass = md5( KStr( pPass ) );

                        Msg2.WriteString( KStr( pLogin ) );
                        Msg2.WriteString( sCryptedPass );
                        SendMessage( Msg2 );
                        g_Console << "Checking authenticity..." << KENDL;
                        return;
                }

        case KPGM_AUTHENTICITYRESULT:
                {
                        // Resultat de l'authentification
                        bool    bResult;
                        Msg >> bResult;

                        if( bResult )
                                g_Console << "Authenticity succeded!" << KENDL;
                        else
                                g_Console << "Authenticity failed!" << KENDL;
                        return;
                }

        case KPGM_GETCLIENTINFOS:
                {
                        // Envoie les infos clients
                        KNetMsg         Msg2;
                        KP_WriteGM( Msg2, KPGM_CLIENTINFOS );
                        // Nom
                        Msg2.WriteString( KStr( pGameClient->GetpName() ) );
                        SendMessage( Msg2 );
                        g_Console << "Sending client infos." << KENDL;
                        return;
                }

        case KPGM_STARTGAMEENGINE:
                {
                        // Demarre le game manager
                        if( pGameClient->GetClientGameManager() )
                                pGameClient->GetClientGameManager()->OnConnect();
                        g_Console << "Starting game manager..." << KENDL;
                        return;
                }

        case KPGM_GAMEMESSAGE:
                {
                        KGAMEMSGTYPE    MsgType;
                        u8                              Byte;
                        Msg >> Byte;
                        MsgType = (KGAMEMSGTYPE)Byte;
                        if( pGameClient->GetClientGameManager() )
                                pGameClient->GetClientGameManager()->OnMessage( MsgType, Msg );
                        return;
                }

        case KPGM_TEXTMESSAGE:
                {
                        KStr    sText;
                        KStr    sChat;

                        Msg.ReadString( sText );
                        sChat = sText;

                        g_Console << sChat << KENDL;
                        if( pGameClient->GetInterface() )
                                pGameClient->GetInterface()->AddChatLine( sChat.GetpString(), KRGB( 150, 25, 107 ) );
                        return;
                }

        default:
                KError::Warning( NULL, "KNetClient::OnMessage() : Unknown KPGENERALMESSAGE type %i", MsgType );
                return;
        }
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::RequestServersList()
{
        if( g_pInterface )
                g_pInterface->OnFlushServersList();

        // Requete Lobby
        KLobbyRequest   Request( KPGM_GETSERVERSLIST );

        m_LobbyRequestId = Request.m_RequestId;

        if( !m_LobbySocket.SendTo( m_LobbyAddr, &Request, sizeof( Request ) ) )
        {
                KError::Error( NULL, GetLastError(), "KNetClient::RequestServersList() : SendTo failed" );
                return false;
        }

        // Requete Broadcast
        KNetMsg         Msg;
        KInetAddr       Addr;

        Msg << m_LobbyRequestId;

        u16     ServerPort      = (u16)g_pGame->GetpIniFile()->ReadInt( "NETWORK", "ServerPort", 28100 );
//      for( u32 Host = 0; Host < m_nLocalAddr; Host ++ )
        {
/*              u32     Address = m_pLocalAddr[Host].GetAddress();
                u8      Addr1 = u8( Address );
                u8      Addr2 = u8( Address >> 8 );
                u8      Addr3 = u8( Address >> 16 );
                u8      Addr4 = 255;
*/
        //      Addr.SetAddress( Addr1, Addr2, Addr3, Addr4 );
                Addr.SetAddress( "255.255.255.255" );
                Addr.SetPort( ServerPort );
                BroadCastMessage( Addr, Msg );
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
bool KNetClient::ManageLobbySocket()
{
        // Lecture depuis la socket lobby
        while( m_LobbySocket.SelectRead() )
        {
                u32                     ByteRead = 0;
                char            pBuffer[1024];

                if( !m_LobbySocket.ReceiveFrom( m_LobbyAddr, pBuffer, sizeof( pBuffer ), &ByteRead ) )
                        return false;

                KNetMsg Msg;
                Msg.WriteBuffer( pBuffer, ByteRead );
                ReadServerInfo( Msg );
        }

        return true;
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::ReadServerInfo( KNetMsg& Msg )
{
        u16             RequestId;
        KStr    sHostName;
        u16             Port;
        u32             Players;
        u32             MaxPlayers;
        u32             Version;
        KStr    sName;

        Msg >> RequestId;
        Msg.ReadString( sHostName );// Address
        Msg >> Port                                     // Port
                >> Players                              // Players
                >> MaxPlayers                   // Max players
                >> Version;                             // Version
        Msg.ReadString( sName );        // Name
        
        if( RequestId == m_LobbyRequestId )
        {
                KServerInfo             ServerInfo;

                ServerInfo.SetsHostName( sHostName );
                ServerInfo.SetListenPort( Port );
                ServerInfo.SetsName( sName );
                ServerInfo.SetPlayers( Players );
                ServerInfo.SetMaxPlayers( MaxPlayers );
                ServerInfo.SetVersion( Version );

                if( g_pInterface )
                        g_pInterface->OnAddServersList( ServerInfo );
        }
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::CommandGetServersList( KStr Argument, void* pContext )
{
        ((KNetClient*)&((KGameClient*)g_pGame)->GetNet())->RequestServersList();
}

//---------------------------------------------------------------------------------------------------------------------
void KNetClient::OnUCMessage( KInetAddr& Addr, char* pBuffer, u32 Size )
{
        KNetMsg         Msg;

        Msg.WriteBuffer( pBuffer, Size );
        
        ReadServerInfo( Msg );
}

---