SraClientConnection.cpp

Go to the documentation of this file.

/*
* SRAClientConnection - The connection between the SRA server and the UDK.
* All those methods may be called from UnrealScript code by using:
*  DLLBind(SraClientConnection);
* 
* @Author Michael Matzen <mim@informatik.uni-kiel.de>
*
* This program 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.
*
* This program 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
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin St, Fifth Floor, Boston, MA 02110, USA
* 
*/

#include "stdio.h"
#include "stdlib.h"
#include <vector>
#include "Connectivity.h"

#include "LoginPacket.h"
#include "LoginReplyPacket.h"
#include "GetClientCharactersPacket.h"
#include "ConnectToServerPacket.h"
#include "GetServerListPacket.h"
#include "ReplyPacket.h"
#include "CreateCharacterPacket.h"
#include "JoinChannelPacket.h"
#include "LeaveChannelPacket.h"
#include "ChatMessage.h"
#include "SendMessageToChannelPacket.h"

#include "Utils.h"


extern "C" 
{
    using namespace SraNetwork;
    using namespace RakNet;

    struct FString
    {
        wchar_t* Data;
        int ArrayNum;
        int ArrayMax;
    };

    // Struct for data movement:
    struct ServerReplyMessages
    {
        int resultCode;
        FString message;
    };

    struct DEBUGServerReplyMessage
    {
        int resultCode;
        wchar_t* message;
    };

    static RakNet::RakPeerInterface *m_rServerInterface;

    // TODO: Support multiple chat interfaces.
    static RakNet::RakPeerInterface *m_rChatServerInterface;

    static int myPID = -1;
    static int myCharID = -1;
    static RakNet::PublicKey publicKey;

    __declspec(dllexport) bool SraConnectToServer(const wchar_t* serverAddress)
    {
        printf("Start connecting\n");
        //Load public key:
    /*  char public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
        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);
        publicKey.publicKey = public_key;
        publicKey.publicKeyMode = RakNet::PKM_USE_KNOWN_PUBLIC_KEY;
*/
        //Do not connect when the interface is already connected
        if (m_rServerInterface && m_rServerInterface->NumberOfConnections() > 0) 
        {
            printf("Already connected!\n");
            return true;
        }
        //Start connecting
        m_rServerInterface = RakNet::RakPeerInterface::GetInstance();
        RakNet::SocketDescriptor serverSocket(SraNetwork::CLIENT_SERVER_PORT, 0);
        m_rServerInterface->Startup(1, &serverSocket, 1);
        //Convert wchar_t* -> char*
        char *saddr = new char[wcslen(serverAddress)+1];
        size_t res=0;
        wcstombs_s( &res, saddr, strlen(saddr), (const wchar_t*)serverAddress, strlen(saddr));
        //wcstombs(saddr, serverAddress, wcslen(serverAddress));

        printf("Connecting to world server @ %s\n", saddr);
        RakNet::ConnectionAttemptResult result = 
            m_rServerInterface->Connect(SraNetwork::WORLD_SERVER_ADDR, SraNetwork::SERVER_CLIENT_PORT, 0, 0, &publicKey);

        // Only check if the connection attempt was succesfull, everything else will be handled by poll()
        if (result != RakNet::ConnectionAttemptResult::CONNECTION_ATTEMPT_STARTED)
        {
            return false;
        }
        return true;
    }

    __declspec(dllexport) bool SraConnectToChatServer(const wchar_t* serverAddress)
    {
        //Load public key:
    /*  char public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
        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);
        publicKey.publicKey = public_key;
        publicKey.publicKeyMode = RakNet::PKM_USE_KNOWN_PUBLIC_KEY;
*/
        //Do not connect when the interface is already connected
        if (m_rChatServerInterface && m_rChatServerInterface->NumberOfConnections() > 0) 
        {
            printf("Already connected!\n");
            return true;
        }
        //Start connecting
        m_rChatServerInterface = RakNet::RakPeerInterface::GetInstance();
        RakNet::SocketDescriptor serverSocket(SraNetwork::CLIENT_CHAT_PORT, 0);
        m_rChatServerInterface->Startup(1, &serverSocket, 1);
        //Convert wchar_t* -> char*
        char *saddr = new char[wcslen(serverAddress)+1];
        size_t res=0;
        wcstombs_s( &res, saddr, strlen(saddr), (const wchar_t*)serverAddress, strlen(saddr));
        //wcstombs(saddr, serverAddress, wcslen(serverAddress));

        printf("Connecting to chat server @ %s\n", saddr);
        RakNet::ConnectionAttemptResult result = 
            m_rChatServerInterface->Connect(saddr, SraNetwork::CHAT_CLIENT_PORT, 0, 0, &publicKey);

        // Only check if the connection attempt was succesfull, everything else will be handled by poll()
        if (result != RakNet::ConnectionAttemptResult::CONNECTION_ATTEMPT_STARTED)
        {
            return false;
        }
        return true;
    }

    __declspec(dllexport) bool SraReconnect()
    {
        return true;
    }
    
    __declspec(dllexport) void SraShutdown() 
    {
        if (m_rServerInterface) 
        {
            m_rServerInterface->CloseConnection( RakNet::UNASSIGNED_SYSTEM_ADDRESS, true, 0, HIGH_PRIORITY);
            m_rServerInterface->Shutdown(1000,0,HIGH_PRIORITY);
        }
    }

    __declspec(dllexport) void testServerForPackageOverflow()
    {
        if (!m_rServerInterface) {
            printf("Not connected !\n");
            return;
        }
        struct BigSraPacket {
        unsigned char opcode; //SraMessageIdentifiers
        int pID;
        wchar_t data[6000];
        };

        BigSraPacket bigpack;
        ZeroMemory(&bigpack, sizeof(bigpack));
        bigpack.pID = 12;
        bigpack.opcode = SraNetwork::ID_LOGIN_REQ;
        memset( bigpack.data, 1203, 6000);
        m_rServerInterface->Send( (char*)&bigpack, sizeof(bigpack), HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
    }

    __declspec(dllexport) bool SraLogin(const wchar_t* user, const wchar_t* pw)
    {
        if (!m_rServerInterface) {
            printf("Not connected !\n");
            return false;
        }
        LoginPacket packet;
        packet.opCode = SraNetwork::ID_LOGIN_REQ;
        packet.username = RakString(convertString(user).c_str());
        packet.password = RakString(convertString(pw).c_str());

        // Serialize packet
        RakNet::BitStream stream;
        packet.Serialize(&stream);

        // Send data
        uint32_t sentData = m_rServerInterface->Send( &stream,
            HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
        //printf("Done sending %d bytes\n", sentData);
        return true;
    }

    __declspec(dllexport) wchar_t* SraGetZone()
    {
        if (!m_rServerInterface || myPID == -1) 
        {
            printf("Not connected\n");
            return NULL;
        }
        return NULL;
        //SraNetwork::SraPacket packet;
        //ZeroMemory(&packet,sizeof(packet));
        //packet.opcode = SraNetwork::ID_CONNECT_TO_SRV;
        //packet.pID = myPID;
        //m_rServerInterface->Send( (char*)&packet, 
        //sizeof(packet), HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
        //bool done = false;
        //static wchar_t zoneAddress[SraNetwork::PACKAGE_DATA_SIZE];
        //RakNet::Packet* p;
        //while ( !done)
        //{
        //  p = m_rServerInterface->Receive();
        //  if (p) 
        //  {
        //      if (p->data[0] == SraNetwork::ID_CONNECT_TO_SRV) 
        //      {
        //          SraNetwork::SraPacket *sPack = (SraNetwork::SraPacket*)p->data;
        //          wcscpy_s( zoneAddress, sPack->data);

        //      } else 
        //      {
        //          printf("Invalid packet received\n");
        //      }
        //      done = true;
        //  }
        //  m_rServerInterface->DeallocatePacket(p);
        //}
        //return zoneAddress;
    }

    
    __declspec(dllexport) bool SraJoinChannel( int channelID )
    {
        if (!m_rServerInterface) {
            printf("Not connected !\n");
            return false;
        }

        JoinChannelPacket p;
        p.channelId = channelID;

        BitStream stream;
        p.Serialize(&stream);

        m_rServerInterface->Send( &stream, 
        HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);

        return true;
    }

    __declspec(dllexport) bool SraLeaveChannel( int channelID )
    {
        if (!m_rServerInterface) {
            printf("Not connected !\n");
            return false;
        }

        LeaveChannelPacket p;
        p.channelId = channelID;

        BitStream stream;
        p.Serialize(&stream);

        m_rServerInterface->Send( &stream, 
        HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);

        return true;
    }

    //Sends a message to the server
    __declspec(dllexport) bool SraSendMessage(const wchar_t* msg) 
    {
        if (!m_rChatServerInterface) {
            printf("Not connected !\n");
            return false;
        }

        SendMessageToChannelPacket p;
        p.channelId = 0;
        p.chatMessage =RakNet::RakString(convertString(msg).c_str());
        BitStream stream;
        p.Serialize(&stream);
        
        m_rChatServerInterface->Send( &stream, 
        HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
        
        return true;
    }

    
    __declspec(dllexport) bool SraCreateCharacter(int raceID, const wchar_t* name)
    {
        if (!m_rServerInterface) {
            printf("Not connected !\n");
            return false;
        }

        CreateCharacterPacket packet;

        packet.characterInfo.raceId = raceID;
        packet.characterInfo.charName = RakNet::RakString(convertString(name).c_str());

        RakNet::BitStream stream;
        packet.Serialize(&stream);
        m_rServerInterface->Send( &stream, 
            MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);

        return true;
    }

    __declspec(dllexport) DEBUGServerReplyMessage Poll()
    {
        DEBUGServerReplyMessage result;
        memset(&result, 0, sizeof(DEBUGServerReplyMessage));
        result.resultCode = 0;

        // This methods should be called in every tick to process 
        // a message.
        if (!m_rServerInterface) {
            // Better not print a message in every tick :P
            //printf("Not connected!\n");
            result.resultCode = -1;
            result.message = L"Not connected to a server\n";
            return result;
        }
        RakNet::Packet *m_pPacket;
        m_pPacket = m_rServerInterface->Receive();
        if (m_pPacket) 
        {
            // First check the RakNet internals.
            if (m_pPacket->data[0] == ID_CONNECTION_REQUEST_ACCEPTED) 
            {
                result.message = L"Connected!\n";
                result.resultCode = 1;
            } 
            //If the world server does not respond, RakNet will return a connection attempt failed packet
            else if (m_pPacket->data[0] == ID_CONNECTION_ATTEMPT_FAILED)
            {
                result.message = L"Failed to connect!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_REMOTE_SYSTEM_REQUIRES_PUBLIC_KEY)
            {
                result.message = L"Remote systems requires public key!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_OUR_SYSTEM_REQUIRES_SECURITY)
            {
                result.message = L"Server does not support security!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_PUBLIC_KEY_MISMATCH)
            {
                result.message = L"Public key does not match server key!\n";
                result.resultCode= -1;
            }
            else 
            {
                // Now for our own packets. 
                BitStream stream(m_pPacket->data, m_pPacket->length, false);
                SraPacket sraPacket;
                sraPacket.Deserialize(&stream);

                switch (sraPacket.opCode)
                {
                    case SraNetwork::ID_LOGIN_REP:
                        {
                            LoginReplyPacket login;
                            login.Deserialize(&stream);
                            // Switch between char and player Id
                            myPID = login.clientID;
                            result.message = L"Succesfully logged in!\n";
                            result.resultCode = 1;
                        }
                        break;
                    case SraNetwork::ID_SRA_REPLY:
                        {
                            ReplyPacket reply;
                            reply.Deserialize(&stream);
                            if (reply.replyCode == ReplyPacket::OK)
                            {
                                switch (reply.messageOpCode)
                                {
                                    case SraNetwork::ID_CREATE_CHAR:
                                    {
                                        result.message = L"Character successfully created\n";
                                        result.resultCode = 1;
                                    }
                                    case SraNetwork::ID_CHAT_CHANNEL_REGISTER:
                                    {
                                        result.message = convertString(reply.replyMessage.C_String());
                                        result.resultCode = 2;
                                    }
                                    break;
                                    default:
                                    break;
                                }
                            }
                            else 
                            {
                                switch (reply.messageOpCode)
                                {
                                    case SraNetwork::ID_CREATE_CHAR:
                                    {
                                        result.message = convertString(reply.replyMessage.C_String());
                                        result.resultCode = -2;
                                    }
                                    break;
                                    case SraNetwork::ID_LOGIN_REP:
                                    {
                                        result.message = convertString(reply.replyMessage.C_String());
                                        result.resultCode = -2;
                                    }
                                    break;
                                }
                            }
                        }
                        break;
                    default:
                        result.message = L"Invalid packet received\n";
                        result.resultCode = 1;
                        break;
                }               
            }
            m_rServerInterface->DeallocatePacket(m_pPacket);
        }
        return result;
    }

    __declspec(dllexport) DEBUGServerReplyMessage PollChatMessages()
    {
        DEBUGServerReplyMessage result;
        memset(&result, 0, sizeof(DEBUGServerReplyMessage));
        result.resultCode = -100;

        if (!m_rChatServerInterface) {
            result.resultCode = -100;
            result.message = L"Not connected to a server\n";
            return result;
        }

        RakNet::Packet *m_pPacket;
        m_pPacket = m_rChatServerInterface->Receive();

        if (m_pPacket) 
        {
            // First check the RakNet internals.
            if (m_pPacket->data[0] == ID_CONNECTION_REQUEST_ACCEPTED) 
            {
                result.message = L"Connected to Chat server!\n";
                result.resultCode = -1;
            } 
            //If the world server does not respond, RakNet will return a connection attempt failed packet
            else if (m_pPacket->data[0] == ID_CONNECTION_ATTEMPT_FAILED)
            {
                result.message = L"Failed to connect to chat server!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_REMOTE_SYSTEM_REQUIRES_PUBLIC_KEY)
            {
                result.message = L"Remote systems requires public key!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_OUR_SYSTEM_REQUIRES_SECURITY)
            {
                result.message = L"Server does not support security!\n";
                result.resultCode = -2;
            }
            else if (m_pPacket->data[0] == ID_PUBLIC_KEY_MISMATCH)
            {
                result.message = L"Public key does not match server key!\n";
                result.resultCode= -2;
            }
            else 
            {
                // Now for our own packets. 
                BitStream stream(m_pPacket->data, m_pPacket->length, false);
                SraPacket sraPacket;
                sraPacket.Deserialize(&stream);

                switch (sraPacket.opCode)
                {
                    case SraNetwork::ID_CHAT_CHANNEL_MESSAGE:
                        {
                            SendMessageToChannelPacket message;
                            message.Deserialize(&stream);
                            
                            result.message = convertString(message.chatMessage.C_String());
                            result.resultCode = message.channelId;
                        }
                        break;                  
                    default:
                        result.message = L"";
                        result.resultCode = -100;
                        break;
                }               
            }
            m_rChatServerInterface->DeallocatePacket(m_pPacket);
        }
        return result;
    }
}