WorldServer.cpp

Go to the documentation of this file.

#include "WorldServer.h"
#include "ClientRegister.h"
#include "MessagePump.h"
#include "ReplyPacket.h"
#include "JoinChannelPacket.h"

namespace SraNetwork {

    //RakNet interfaces.
    static RakPeerInterface *m_rZoneInterface,*m_rClientInterface, *m_rChatInterface;
    static char public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
    static char private_key[cat::EasyHandshake::PRIVATE_KEY_BYTES];

    WorldServer::WorldServer(void)
    {
    }

    WorldServer::~WorldServer(void)
    {
    }


    RakPeerInterface* WorldServer::getZoneInterface()
    {
        return m_rZoneInterface;
    }

    RakPeerInterface* WorldServer::getClientInterface()
    {
        return m_rClientInterface;
    }
    
    RakPeerInterface* WorldServer::getChatinterface(const int channelId)
    {
        //TODO: Support multiple chat server interfaces for
        // load balancing.
        return m_rChatInterface;
    }

    bool WorldServer::Initialize(void)
    {
        //Load key pair
        FILE* fp;
        fopen_s(&fp, "sra_public.key","r");
        if (!fp) 
        {
            printf("Public key not found!\n");
            return false;
        }
        fread(public_key, sizeof(public_key), 1, fp);
        fclose(fp);

        fopen_s(&fp, "sra_private.key", "r");
        if (!fp)
        {
            printf("Private key not found!\n");
            return false;
        }
        fread(private_key, sizeof(private_key), 1, fp);
        fclose(fp);

        return true;
    }

    void WorldServer::ChatServerConnectionThread()
    {
        printf("Listening for chat server ..... \n");
        m_rChatInterface = RakPeerInterface::GetInstance();
        SocketDescriptor chatSocket(SraNetwork::SERVER_CHAT_PORT, 0);
        m_rChatInterface->Startup(2, &chatSocket, 1);
        m_rChatInterface->SetMaximumIncomingConnections(2); //2 ?

        bool running = true;
        bool status = false;

        while (running)
        {
            Packet *packet = m_rChatInterface->Receive();
            if (packet) 
            {
                if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) 
                {
                    printf("Chat server connected\n");
                    status = true;
                }
                running = false;
                m_rChatInterface->DeallocatePacket(packet);
            }
            Sleep(10);
        }
        if (!status)
        {
            printf("Error while accepting chat server connection\n");
            m_rChatInterface->Shutdown(0);
            return;
        }
        running=true;
        while (running)
        {
            Packet *packet = m_rChatInterface->Receive();
            if (packet) 
            {
                //We are processing the chat packets right here, because we have only
                //one chat server, so no need for tasks here.....maybe later ^^
                if ( packet->data[0] == ID_CONNECTION_LOST ) 
                {
                    printf("Lost connection to chat server!\n");
                    running = false;
                }  
                else //if ( p->opCode == ID_CHAT_CHANNEL_REGISTER) 
                {
                    // Now for our own packets. 
                    BitStream stream(packet->data, packet->length, false);
                    SraPacket sraPacket;
                    sraPacket.Deserialize(&stream);
                    switch (sraPacket.opCode)
                    {
                        case ID_CHAT_CHANNEL_REGISTER:
                        {
                            printf("Received a channel registration message from the chat server, forwarding it to the client!\n");
                            // We will only receive this packet if a 
                            // player has joined a channel succesfully
                            // So create a forward message with the server ip.
                            //If the channel join failed, send a reply to the client
                            JoinChannelPacket jp;
                            jp.Deserialize(&stream);

                            RakPeerInterface *clientI = SraNetwork::WorldServer::getClientInterface();

                            BitStream stream;

                            ReplyPacket rp;
                            rp.replyCode = ReplyPacket::OK;
                            rp.replyMessage = SraNetwork::CHAT_SERVER_ADDR;
                            rp.messageOpCode = SraNetwork::ID_CHAT_CHANNEL_REGISTER;
                            rp.Serialize(&stream);
                            clientI->Send( &stream, 
                            MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, jp.clientAddress, false);
                        }
                        break;
                    }
                }
                //TODO: Check for other RakNet connection flags.
                
                m_rChatInterface->DeallocatePacket(packet);
            }
            Sleep(10);
        }
    }


    void WorldServer::ZoneServerConnectionThread()
    {
        printf("Listening for zones ....\n");
        m_rZoneInterface = RakPeerInterface::GetInstance();
        SocketDescriptor zoneSocket(SraNetwork::SERVER_ZONE_PORT, 0);
        m_rZoneInterface->Startup(2, &zoneSocket, 1);
        m_rZoneInterface->SetMaximumIncomingConnections(2);
        
        bool running = true;
        bool status = false;
        while (running)
        {
            Packet *packet = m_rZoneInterface->Receive();
            if (packet) 
            {
                if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) 
                {
                    printf("Zone server connected\n");
                    status = true;
                }
                running = false;
                m_rZoneInterface->DeallocatePacket(packet);
            }
            Sleep(10);
        }
        if (!status)
        {
            printf("Error while accepting zone server connection\n");
            m_rZoneInterface->Shutdown(0);
            return;
        }
        running=true;
        while (running)
        {
            Packet *packet = m_rZoneInterface->Receive();
            if (packet) 
            {
                //We are processing the zone packets right here, because we have only
                //one zone server, so no need for tasks here.....maybe later ^^
                SraZonePacket* p = (SraZonePacket*)packet->data;
                if ( packet->data[0] == ID_CONNECTION_LOST ) {
                    printf("Lost connection to zone server!\n");
                    running = false;
                }  //TODO: Check for other RakNet connection flags.
                else if ( p->toZoneID != -1) 
                {
                    printf("Zone answer received, forwarding to client\n");
                    //Send ack to client
                    SraPacket2 answer;
                    ZeroMemory(&answer,sizeof(answer));
                    answer.opcode = ID_CONNECT_TO_SRV;
                    answer.pID = -1;
                    SystemAddress *sa = const_cast<SystemAddress*>(ClientRegister::getInstance()->getAddressFromClientID(p->clientID));

                    //We are now sending the address of the zone server and the port:
                    //TODO Reimpl this
                    /*std::string str;
                    str << SraNetwork::ZONE_SERVER_ADDR << ":" <<  p->toZoneID;
                    memcpy( answer.data, str.str().c_str(), strlen(str.str().c_str()));*/

                    //wcscpy_s( answer.data , str.str().c_str());
                    printf("Sending zone answer : %ls to clientID %d", answer.data, p->clientID);
                    m_rClientInterface->Send( (char*)&answer, sizeof(answer), HIGH_PRIORITY, RELIABLE_ORDERED, 0,*sa, false);
                }
                m_rZoneInterface->DeallocatePacket(packet);
            }
            Sleep(10);
        }
    }

    void WorldServer::ClientConnectionThread()
    {
        printf("Listening for clients ....\n");
        m_rClientInterface = RakPeerInterface::GetInstance();       
        //We are now using the RakNet security features:
        //if (!m_rClientInterface->InitializeSecurity(NULL, NULL))//InitializeSecurity(public_key,private_key)) 
        //{
        //  printf("Invalid keys!\n");
        //}

        SocketDescriptor clientSocket(SraNetwork::SERVER_CLIENT_PORT, 0);
        m_rClientInterface->Startup(SraNetwork::MAX_CLIENTS, &clientSocket, 1);
        m_rClientInterface->SetMaximumIncomingConnections(MAX_CLIENTS);

        //Root task:
        tbb::task& rootTask = *new( tbb::task::allocate_root() )tbb::empty_task;
        rootTask.set_ref_count( 2 );
        //int n = tbb::task_scheduler_init::default_num_threads();
        //tbb::task_scheduler_init init(3);
        //printf("Num Threads %d\n", n);

        while (1) 
        {
            Packet *packet = m_rClientInterface->Receive();
            if (packet) 
            {
                // Add message to the queue
                MessagePump::Instance->AddMessage( packet );
                m_rClientInterface->DeallocatePacket(packet);
            }
            Sleep(10);
        }
    }

}