Example #1
0
        public void HandleHandshakeReplyReceivedMessage(HandshakeReplyMsgData data)
        {
            TimeSyncerSystem.ServerStartTime = data.ServerStartTime;

            HandshakeReply reply;
            string         reason;
            var            modFileData = "";

            try
            {
                reply  = data.Response;
                reason = data.Reason;
                //If we handshook successfully, the mod data will be available to read.
                if (reply == HandshakeReply.HandshookSuccessfully)
                {
                    SystemsContainer.Get <ModSystem>().ModControl = data.ModControlMode;
                    if (SystemsContainer.Get <ModSystem>().ModControl != ModControlMode.Disabled)
                    {
                        modFileData = Encoding.UTF8.GetString(data.ModFileData);
                    }
                }
            }
            catch (Exception e)
            {
                LunaLog.LogError($"[LMP]: Error handling HANDSHAKE_REPLY Message, exception: {e}");
                reply  = HandshakeReply.MalformedHandshake;
                reason = "Incompatible HANDSHAKE_REPLY Message";
            }

            switch (reply)
            {
            case HandshakeReply.HandshookSuccessfully:

                if (ModFileHandler.ParseModFile(modFileData))
                {
                    LunaLog.Log("[LMP]: Handshake successful");
                    MainSystem.NetworkState = ClientState.Authenticated;
                }
                else
                {
                    LunaLog.LogError("[LMP]: Failed to pass mod validation");
                    NetworkConnection.Disconnect("[LMP]: Failed mod validation");
                }
                break;

            default:
                var disconnectReason = $"Handshake failure: {reason}";
                //If it's a protocol mismatch, append the client/server version.
                if (reply == HandshakeReply.ProtocolMismatch)
                {
                    disconnectReason += $"\nClient: {LmpVersioning.CurrentVersion}, Server: {data.MajorVersion}.{data.MinorVersion}.{data.BuildVersion}";
                }
                LunaLog.Log(disconnectReason);
                NetworkConnection.Disconnect(disconnectReason);
                break;
            }
        }
        public void HandleHandshakeReplyReceivedMessage(HandshakeReplyMsgData data)
        {
            HandshakeReply reply;
            string         reason;
            var            modFileData = "";

            try
            {
                reply  = data.Response;
                reason = data.Reason;
                //If we handshook successfully, the mod data will be available to read.
                if (reply == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
                {
                    ModSystem.Singleton.ModControl = data.ModControlMode;
                    if (ModSystem.Singleton.ModControl != ModControlMode.DISABLED)
                    {
                        modFileData = Encoding.UTF8.GetString(data.ModFileData);
                    }
                }
            }
            catch (Exception e)
            {
                Debug.LogError($"[LMP]: Error handling HANDSHAKE_REPLY Message, exception: {e}");
                reply  = HandshakeReply.MALFORMED_HANDSHAKE;
                reason = "Incompatible HANDSHAKE_REPLY Message";
            }

            switch (reply)
            {
            case HandshakeReply.HANDSHOOK_SUCCESSFULLY:
            {
                if (ModFileParser.ParseModFile(modFileData))
                {
                    Debug.Log("[LMP]: Handshake successful");
                    MainSystem.Singleton.NetworkState = ClientState.AUTHENTICATED;
                }
                else
                {
                    Debug.LogError("[LMP]: Failed to pass mod validation");
                    NetworkConnection.Disconnect("[LMP]: Failed mod validation");
                }
            }
            break;

            default:
                var disconnectReason = "Handshake failure: " + reason;
                //If it's a protocol mismatch, append the client/server version.
                if (reply == HandshakeReply.PROTOCOL_MISMATCH)
                {
                    disconnectReason += "\nClient: " + VersionInfo.VersionNumber + ", Server: " + data.Version;
                }
                Debug.Log(disconnectReason);
                NetworkConnection.Disconnect(disconnectReason);
                break;
            }
        }
        public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason)
        {
            var messageData = new HandshakeReplyMsgData
            {
                Response = enumResponse,
                Reason   = reason
            };

            if (enumResponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY)
            {
                messageData.ModControlMode = GeneralSettings.SettingsStore.ModControl;
                if (GeneralSettings.SettingsStore.ModControl != ModControlMode.DISABLED)
                {
                    if (!FileHandler.FileExists(ServerContext.ModFilePath))
                    {
                        ModFileSystem.GenerateNewModFile();
                    }
                    messageData.ModFileData = FileHandler.ReadFile(ServerContext.ModFilePath);
                }
            }

            MessageQueuer.SendToClient <HandshakeSrvMsg>(client, messageData);
        }
        public void HandleHandshakeReplyReceivedMessage(HandshakeReplyMsgData data)
        {
            TimeSyncSystem.ServerStartTime = data.ServerStartTime;

            switch (data.Response)
            {
            case HandshakeReply.HandshookSuccessfully:
                ModSystem.Singleton.Clear();
                ModSystem.Singleton.ModControl = data.ModControl;
                if (ModSystem.Singleton.ModControl)
                {
                    if (ModSystem.Singleton.ModFileHandler.ParseModFile(ModFileParser.ReadModFileFromString(data.ModFileData)))
                    {
                        LunaLog.Log("[LMP]: Handshake successful");
                        MainSystem.NetworkState = ClientState.Handshaked;
                    }
                    else
                    {
                        LunaLog.LogError("[LMP]: Failed to pass mod validation");
                        NetworkConnection.Disconnect("[LMP]: Failed mod validation");
                    }
                }
                else
                {
                    LunaLog.Log("[LMP]: Handshake successful");
                    MainSystem.NetworkState = ClientState.Handshaked;
                }
                break;

            default:
                var disconnectReason = $"Handshake failure: {data.Reason}";
                LunaLog.Log(disconnectReason);
                NetworkConnection.Disconnect(disconnectReason);
                break;
            }
        }