public void SendMessage(PiranhaMessage message)
{
ClientConnectionState state = this.m_connection.State;
if (state != ClientConnectionState.LOGGED)
{
if (state == ClientConnectionState.DISCONNECTED)
{
return;
}
int messageType = message.GetMessageType();
if (messageType != LoginFailedMessage.MESSAGE_TYPE &&
messageType != LoginOkMessage.MESSAGE_TYPE &&
messageType != UnlockAccountFailedMessage.MESSAGE_TYPE &&
messageType != UnlockAccountOkMessage.MESSAGE_TYPE)
{
return;
}
if (messageType == LoginFailedMessage.MESSAGE_TYPE)
{
this.m_connection.SetState(ClientConnectionState.LOGIN_FAILED);
}
}
this.m_connection.Messaging.Send(message);
}
private bool IsRequestPiranhaMessage(PiranhaMessage message)
{
int messageType = message.GetMessageType();
return(messageType == AskForAvatarProfileMessage.MESSAGE_TYPE ||
messageType == AskForAllianceDataMessage.MESSAGE_TYPE);
}
private static void OnForwardLogicRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForJoinableAlliancesListMessage.MESSAGE_TYPE:
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId), 5).OnComplete = args =>
{
SearchMessageManager.OnAvatarResponseMessageReceivedForJoinableAlliancesList(message, args);
};
break;
case SearchAlliancesMessage.MESSAGE_TYPE:
SearchMessageManager.OnSearchAlliancesMessageReceived((SearchAlliancesMessage)logicMessage, message);
break;
}
}
}
private static void OnForwardLogicMessageRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAllianceDataMessage.MESSAGE_TYPE:
AskForAllianceDataMessage askForAllianceDataMessage = (AskForAllianceDataMessage)logicMessage;
LogicLong allianceId = askForAllianceDataMessage.RemoveAllianceId();
if (AllianceManager.TryGet(allianceId, out Alliance alliance))
{
ServerMessageManager.SendMessage(StreamMessageManager.CreateForwardLogicMessage(alliance.GetAllianceDataMessage(), message.SessionId),
ServerManager.GetProxySocket(message.SessionId));
}
break;
}
}
}
/// <summary>
/// Receives the specified message.
/// </summary>
internal void ReceiveMessage(PiranhaMessage message)
{
int messageType = message.GetMessageType();
switch (messageType)
{
case 20103:
{
this.LoginFailedMessageReceived((LoginFailedMessage)message);
break;
}
case 20104:
{
this.LoginOkMessageReceived((LoginOkMessage)message);
break;
}
case 20108:
{
this.KeepAliveServerReceived((KeepAliveServerMessage)message);
break;
}
default:
{
// Logging.Warning(this, "MessageManager::receiveMessage no case for message type " + messageType);
break;
}
}
}
/// <summary>
/// Receives the specified <see cref="PiranhaMessage"/>.
/// </summary>
internal void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case 14715:
this.SendGlobalChatLineMessageReceived((SendGlobalChatLineMessage)message);
break;
}
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case BattleEndClientTurnMessage.MESSAGE_TYPE:
this.OnBattleEndClientTurnMessageReceived((BattleEndClientTurnMessage)message);
break;
}
}
public void SendMessage(PiranhaMessage message)
{
if (message.GetMessageType() == EndClientTurnMessage.MESSAGE_TYPE || message.GetMessageType() == BattleEndClientTurnMessage.MESSAGE_TYPE)
{
this.m_nextClientTurn = 5f;
}
else if (message.GetMessageType() == KeepAliveMessage.MESSAGE_TYPE)
{
this.m_nextKeepAlive = 0.1f;
if (this.m_sendKeepAliveTime == DateTime.MinValue)
{
this.m_sendKeepAliveTime = DateTime.UtcNow;
}
}
this.m_messaging.Send(message);
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case SendGlobalChatLineMessage.MESSAGE_TYPE:
this.OnSendGlobalChatLineMessageReceived((SendGlobalChatLineMessage)message);
break;
}
}
/// <summary>
/// Writes the message header
/// </summary>
private void WriteHeader(PiranhaMessage message, byte[] packet, int encodingLength)
{
int messageType = message.GetMessageType();
int messageVersion = message.GetMessageVersion();
packet[1] = (byte)(messageType);
packet[0] = (byte)(messageType >> 8);
packet[4] = (byte)(encodingLength);
packet[3] = (byte)(encodingLength >> 8);
packet[2] = (byte)(encodingLength >> 16);
packet[6] = (byte)(messageVersion);
packet[5] = (byte)(messageVersion >> 8);
}
/// <summary>
/// Receives the specified <see cref="PiranhaMessage"/>.
/// </summary>
internal void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case 10212:
this.ChangeAvatarNameMessageReceived((ChangeAvatarNameMessage)message);
break;
case 14325:
this.AskForAvatarProfileMessageReceived((AskForAvatarProfileMessage)message);
break;
}
}
public void SendPiranhaMessage(PiranhaMessage message, int serverType)
{
if (message.GetByteStream().GetLength() == 0)
{
message.Encode();
}
this.SendMessage(new ForwardLogicMessage
{
MessageType = message.GetMessageType(),
MessageVersion = (short)message.GetMessageVersion(),
MessageLength = message.GetEncodingLength(),
MessageBytes = message.GetByteStream().GetByteArray()
}, serverType);
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case LeaveAllianceMessage.MESSAGE_TYPE:
this.OnLeaveAllianceMessageReceived((LeaveAllianceMessage)message);
break;
case ChatToAllianceStreamMessage.MESSAGE_TYPE:
this.OnChatToAllianceStreamMessageReceived((ChatToAllianceStreamMessage)message);
break;
case ChangeAllianceSettingsMessage.MESSAGE_TYPE:
this.OnChangeAllianceSettingsMessageReceived((ChangeAllianceSettingsMessage)message);
break;
case ChangeAllianceMemberRoleMessage.MESSAGE_TYPE:
this.OnChangeAllianceMemberRoleMessageReceived((ChangeAllianceMemberRoleMessage)message);
break;
case DonateAllianceUnitMessage.MESSAGE_TYPE:
this.OnDonateAllianceUnitMessageReceived((DonateAllianceUnitMessage)message);
break;
case CancelChallengeMessage.MESSAGE_TYPE:
this.OnCancelChallengeMessageReceived((CancelChallengeMessage)message);
break;
case ScoutFriendlyBattleMessage.MESSAGE_TYPE:
this.OnScoutFriendlyBattleMessageReceived((ScoutFriendlyBattleMessage)message);
break;
case AcceptFriendlyBattleMessage.MESSAGE_TYPE:
this.OnAcceptFriendlyBattleMessageReceived((AcceptFriendlyBattleMessage)message);
break;
case StartFriendlyChallengeSpectateMessage.MESSAGE_TYPE:
this.OnStartFriendlyChallengeSpectateMessageReceived((StartFriendlyChallengeSpectateMessage)message);
break;
case RespondToAllianceJoinRequestMessage.MESSAGE_TYPE:
this.OnRespondToAllianceJoinRequestMessageReceived((RespondToAllianceJoinRequestMessage)message);
break;
case SendAllianceInvitationMessage.MESSAGE_TYPE:
this.OnSendAllianceInvitationMessageReceived((SendAllianceInvitationMessage)message);
break;
}
}
private static ForwardLogicMessage CreateForwardLogicMessage(PiranhaMessage piranhaMessage, long sessionId)
{
if (piranhaMessage.GetEncodingLength() == 0)
{
piranhaMessage.Encode();
}
return(new ForwardLogicMessage
{
SessionId = sessionId,
MessageType = piranhaMessage.GetMessageType(),
MessageVersion = (short)piranhaMessage.GetMessageVersion(),
MessageLength = piranhaMessage.GetEncodingLength(),
MessageBytes = piranhaMessage.GetMessageBytes()
});
}
public void SendPiranhaMessageToProxy(PiranhaMessage piranhaMessage)
{
if (piranhaMessage.GetEncodingLength() == 0)
{
piranhaMessage.Encode();
}
ServerMessageManager.SendMessage(new ForwardLogicMessage
{
SessionId = this.SessionId,
MessageType = piranhaMessage.GetMessageType(),
MessageVersion = (short)piranhaMessage.GetMessageVersion(),
MessageLength = piranhaMessage.GetEncodingLength(),
MessageBytes = piranhaMessage.GetMessageBytes()
}, ServerManager.GetProxySocket(this.SessionId));
}
private static void OnForwardLogicMessageRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAvatarProfileMessage.MESSAGE_TYPE:
{
AskForAvatarProfileMessage askForAvatarProfileMessage = (AskForAvatarProfileMessage)logicMessage;
LogicLong avatarId = askForAvatarProfileMessage.RemoveAvatarId();
if (GameAvatarManager.TryGet(avatarId, out GameAvatar document))
{
AvatarProfileMessage avatarProfileMessage = new AvatarProfileMessage();
AvatarProfileFullEntry avatarProfileFullEntry = new AvatarProfileFullEntry();
avatarProfileFullEntry.SetLogicClientAvatar(document.LogicClientAvatar);
avatarProfileFullEntry.SetCompressedHomeJSON(document.LogicClientHome.GetCompressibleHomeJSON().GetCompressed());
avatarProfileMessage.SetAvatarProfileFullEntry(avatarProfileFullEntry);
ServerMessageManager.SendMessage(GameMessageManager.CreateForwardLogicMessage(avatarProfileMessage, message.SessionId), ServerManager.GetProxySocket(message.SessionId));
}
else
{
AvatarProfileFailedMessage avatarProfileFailedMessage = new AvatarProfileFailedMessage();
avatarProfileFailedMessage.SetErrorType(AvatarProfileFailedMessage.ErrorType.NOT_FOUND);
ServerMessageManager.SendMessage(GameMessageManager.CreateForwardLogicMessage(avatarProfileFailedMessage, message.SessionId),
ServerManager.GetProxySocket(message.SessionId));
}
break;
}
}
}
}
public void ReceiveMessage(PiranhaMessage piranhaMessage)
{
switch (piranhaMessage.GetMessageType())
{
case LoginFailedMessage.MESSAGE_TYPE:
this.OnLoginFailedMessageReceived((LoginFailedMessage)piranhaMessage);
break;
case LoginOkMessage.MESSAGE_TYPE:
this.OnLoginOkMessageReceived((LoginOkMessage)piranhaMessage);
break;
case KeepAliveServerMessage.MESSAGE_TYPE:
this.OnKeepAliveServerMessageReceived((KeepAliveServerMessage)piranhaMessage);
break;
}
}
/// <summary>
/// Writes the message header to buffer.
/// </summary>
internal static void WriteHeader(PiranhaMessage message, byte[] buffer, int length)
{
int messageType = message.GetMessageType();
int messageVersion = message.GetMessageVersion();
buffer[1] = (byte)messageType;
buffer[0] = (byte)(messageType >> 8);
buffer[4] = (byte)length;
buffer[3] = (byte)(length >> 8);
buffer[2] = (byte)(length >> 16);
buffer[6] = (byte)messageVersion;
buffer[5] = (byte)(messageVersion >> 8);
if (length > 0xFFFFFF)
{
Debugger.Error("Trying to send too big message, type " + messageType);
}
}
private static void WriteHeader(PiranhaMessage message, byte[] stream, int length)
{
int messageType = message.GetMessageType();
int messageVersion = message.GetMessageVersion();
stream[0] = (byte)(messageType >> 8);
stream[1] = (byte)(messageType);
stream[2] = (byte)(length >> 16);
stream[3] = (byte)(length >> 8);
stream[4] = (byte)(length);
stream[5] = (byte)(messageVersion >> 8);
stream[6] = (byte)(messageVersion);
if (length > 0xFFFFFF)
{
Debugger.Error("NetworkMessaging::writeHeader trying to send too big message, type " + messageType);
}
}
private void SendForwardLogicMessageRequestMessage(PiranhaMessage piranhaMessage, ServerSocket socket)
{
if (socket != null)
{
if (this.IsRequestPiranhaMessage(piranhaMessage) && !this.CanSendRequest(piranhaMessage.GetMessageType()))
{
return;
}
ServerMessageManager.SendMessage(new ForwardLogicRequestMessage
{
SessionId = this.m_connection.Session.Id,
AccountId = this.m_connection.Session.AccountId,
MessageType = piranhaMessage.GetMessageType(),
MessageVersion = (short)piranhaMessage.GetMessageVersion(),
MessageLength = piranhaMessage.GetEncodingLength(),
MessageBytes = piranhaMessage.GetMessageBytes()
}, socket);
}
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case GoHomeMessage.MESSAGE_TYPE:
this.OnGoHomeMessageReceived((GoHomeMessage)message);
break;
case EndClientTurnMessage.MESSAGE_TYPE:
this.OnEndClientTurnMessageReceived((EndClientTurnMessage)message);
break;
case VisitHomeMessage.MESSAGE_TYPE:
this.OnVisitHomeMessageReceived((VisitHomeMessage)message);
break;
case AttackNpcMessage.MESSAGE_TYPE:
this.OnAttackNpcMessageReceived((AttackNpcMessage)message);
break;
case DuelNpcMessage.MESSAGE_TYPE:
this.OnDuelNpcMessageReceived((DuelNpcMessage)message);
break;
case CreateAllianceMessage.MESSAGE_TYPE:
this.OnCreateAllianceMessageReceived((CreateAllianceMessage)message);
break;
case JoinAllianceMessage.MESSAGE_TYPE:
this.OnJoinAllianceMessageReceived((JoinAllianceMessage)message);
break;
case RequestJoinAllianceMessage.MESSAGE_TYPE:
this.OnRequestJoinAllianceMessageReceived((RequestJoinAllianceMessage)message);
break;
case JoinAllianceUsingInvitationMessage.MESSAGE_TYPE:
this.OnJoinAllianceUsingInvitationMessageReceived((JoinAllianceUsingInvitationMessage)message);
break;
}
}
/// <summary>
/// Receives the specified message.
/// </summary>
internal void ReceiveMessage(PiranhaMessage message)
{
int messageType = message.GetMessageType();
if (this.ServerConnection.State != 6)
{
if (messageType != 20103 && messageType != 20104)
{
return;
}
}
switch (messageType)
{
case 20103:
{
this.LoginFailedMessageReceived((LoginFailedMessage)message);
break;
}
}
}
private static void OnForwardLogicRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAllianceRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAllianceRankingListMessageReceived((AskForAllianceRankingListMessage)logicMessage, message);
break;
case AskForAvatarRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarRankingListMessageReceived((AskForAvatarRankingListMessage)logicMessage, message);
break;
case AskForAvatarLocalRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForLocalAvatarRankingListMessageReceived((AskForAvatarLocalRankingListMessage)logicMessage, message);
break;
case AskForAvatarLastSeasonRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarLastSeasonRankingListMessageReceived((AskForAvatarLastSeasonRankingListMessage)logicMessage, message);
break;
case AskForAvatarDuelLastSeasonRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarDuelLastSeasonRankingListMessageReceived((AskForAvatarDuelLastSeasonRankingListMessage)logicMessage, message);
break;
}
}
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case ChangeAvatarNameMessage.MESSAGE_TYPE:
this.OnChangeAvatarNameMessageReceived((ChangeAvatarNameMessage)message);
break;
case AvatarNameCheckRequestMessage.MESSAGE_TYPE:
this.OnAvatarNameCheckRequestMessageReceived((AvatarNameCheckRequestMessage)message);
break;
case CancelMatchmakingMessage.MESSAGE_TYPE:
this.OnCancelMatchmakingMessageReceived((CancelMatchmakingMessage)message);
break;
case HomeBattleReplayMessage.MESSAGE_TYPE:
this.OnHomeBattleReplayMessageReceived((HomeBattleReplayMessage)message);
break;
case AskForAllianceBookmarksFullDataMessage.MESSAGE_TYPE:
this.OnAskForAllianceBookmarksFullDataMessageReceived((AskForAllianceBookmarksFullDataMessage)message);
break;
case AddAllianceBookmarkMessage.MESSAGE_TYPE:
this.OnAddAllianceBookmarkMessageReceived((AddAllianceBookmarkMessage)message);
break;
case RemoveAllianceBookmarkMessage.MESSAGE_TYPE:
this.OnRemoveAllianceBookmarkMessageReceived((RemoveAllianceBookmarkMessage)message);
break;
case RemoveAvatarStreamEntryMessage.MESSAGE_TYPE:
this.OnRemoveAvatarStreamEntryMessageReceived((RemoveAvatarStreamEntryMessage)message);
break;
}
}
public void InternalSend(PiranhaMessage message)
{
if (message.GetEncodingLength() == 0)
{
message.Encode();
}
int encodingLength = message.GetEncodingLength();
int encryptedLength;
byte[] encodingBytes = message.GetMessageBytes();
byte[] encryptedBytes;
if (this.m_sendEncrypter != null)
{
if (!this.m_encryptionScrambled && message.GetMessageType() == LoginOkMessage.MESSAGE_TYPE)
{
byte[] nonce = Messaging.CreateNonce();
ExtendedSetEncryptionMessage extendedSetEncryptionMessage = new ExtendedSetEncryptionMessage();
extendedSetEncryptionMessage.SetNonce(nonce);
extendedSetEncryptionMessage.SetNonceMethod(Messaging.NONCE_METHOD);
this.InternalSend(extendedSetEncryptionMessage);
this.SetEncryption(extendedSetEncryptionMessage);
}
encryptedLength = encodingLength + this.m_sendEncrypter.GetOverheadEncryption();
encryptedBytes = new byte[encryptedLength];
this.EncryptUsingEncrypter(encodingBytes, encryptedBytes, encodingLength);
}
else if (this.m_pepperState != PepperState.DISABLED)
{
if (this.m_pepperState == PepperState.AUTHENTIFICATION)
{
if (message.GetMessageType() == ServerHelloMessage.MESSAGE_TYPE)
{
this.m_pepperState = PepperState.AUTHENTIFICATION_SERVER;
}
encryptedLength = encodingLength;
encryptedBytes = encodingBytes;
}
else if (this.m_pepperState == PepperState.LOGIN)
{
throw new NotImplementedException();
}
else
{
encryptedLength = encodingLength;
encryptedBytes = encodingBytes;
}
}
else
{
encryptedBytes = encodingBytes;
encryptedLength = encodingLength;
}
byte[] stream = new byte[encryptedLength + Messaging.HEADER_SIZE];
Messaging.WriteHeader(message, stream, encryptedLength);
Buffer.BlockCopy(encryptedBytes, 0, stream, Messaging.HEADER_SIZE, encryptedLength);
this.m_clientConnection.Send(stream, encryptedLength + Messaging.HEADER_SIZE);
}
public void ReceiveMessage(PiranhaMessage message)
{
int messageType = message.GetMessageType();
int messageServiceNodeType = message.GetServiceNodeType();
ClientConnectionState state = this.m_connection.State;
if (state != ClientConnectionState.LOGGED)
{
if (state == ClientConnectionState.DISCONNECTED)
{
return;
}
if (messageType != ClientHelloMessage.MESSAGE_TYPE && messageType != LoginMessage.MESSAGE_TYPE &&
messageType != KeepAliveMessage.MESSAGE_TYPE && messageType != UnlockAccountMessage.MESSAGE_TYPE)
{
return;
}
}
Logging.Print("MessageManager.receiveMessage: " + message.GetType().Name);
if (messageServiceNodeType == 1)
{
switch (messageType)
{
case ClientHelloMessage.MESSAGE_TYPE:
this.ClientHelloMessageReceived((ClientHelloMessage)message);
break;
case LoginMessage.MESSAGE_TYPE:
this.LoginMessageReceived((LoginMessage)message);
break;
case KeepAliveMessage.MESSAGE_TYPE:
this.KeepAliveMessageReceived((KeepAliveMessage)message);
break;
case UnlockAccountMessage.MESSAGE_TYPE:
this.UnlockAccountMessageReceived((UnlockAccountMessage)message);
break;
case BindFacebookAccountMessage.MESSAGE_TYPE:
this.OnBindFacebookAccountMessageReceived((BindFacebookAccountMessage)message);
break;
}
}
else
{
if (state != ClientConnectionState.LOGGED)
{
return;
}
ProxySession session = this.m_connection.Session;
if (session == null)
{
return;
}
if (this.IsRequestPiranhaMessage(message))
{
switch (messageType)
{
case AskForAvatarProfileMessage.MESSAGE_TYPE:
this.SendForwardLogicMessageRequestMessage(message, ServerManager.GetDocumentSocket(9, ((AskForAvatarProfileMessage)message).RemoveAvatarId()));
break;
case AskForAllianceDataMessage.MESSAGE_TYPE:
this.SendForwardLogicMessageRequestMessage(message, ServerManager.GetDocumentSocket(11, ((AskForAllianceDataMessage)message).RemoveAllianceId()));
break;
}
}
else if (messageServiceNodeType == 28 || messageServiceNodeType == 29)
{
this.SendForwardLogicMessageRequestMessage(message, ServerManager.GetNextSocket(messageServiceNodeType));
}
else
{
session.SendPiranhaMessage(message, messageServiceNodeType);
}
}
}
private int OnReceive(byte[] buffer, int length)
{
if (length >= Messaging.PACKET_HEADER_LENGTH)
{
Messaging.ReadHeader(buffer, out int messageType, out int messageLength, out int messageVersion);
if (length >= Messaging.PACKET_HEADER_LENGTH + messageLength)
{
byte[] encryptedBytes = new byte[messageLength];
byte[] encodingBytes;
Buffer.BlockCopy(buffer, Messaging.PACKET_HEADER_LENGTH, encryptedBytes, 0, messageLength);
int encodingLength;
if (this.m_receiveEncrypter != null)
{
encodingLength = messageLength - this.m_receiveEncrypter.GetOverheadEncryption();
encodingBytes = new byte[encodingLength];
this.m_receiveEncrypter.Decrypt(encryptedBytes, encodingBytes, encodingLength);
}
else
{
encodingLength = messageLength;
encodingBytes = encryptedBytes;
}
PiranhaMessage piranhaMessage = this.m_messageFactory.CreateMessageByType(messageType);
if (piranhaMessage != null)
{
piranhaMessage.SetMessageVersion(messageVersion);
piranhaMessage.GetByteStream().SetByteArray(encodingBytes, encodingLength);
piranhaMessage.Decode();
if (piranhaMessage.GetMessageType() != ExtendedSetEncryptionMessage.MESSAGE_TYPE)
{
this.m_receiveQueue.Enqueue(piranhaMessage);
}
else
{
ExtendedSetEncryptionMessage extendedSetEncryptionMessage = (ExtendedSetEncryptionMessage)piranhaMessage;
byte[] nonce = extendedSetEncryptionMessage.RemoveNonce();
switch (extendedSetEncryptionMessage.GetNonceMethod())
{
case 1:
this.ScrambleNonceUsingMersenneTwister(nonce);
break;
default:
this.ScrambleNonceUsingDefaultMethod(nonce);
break;
}
char[] nonceChars = new char[nonce.Length];
for (int i = 0; i < nonce.Length; i++)
{
nonceChars[i] = (char)nonce[i];
}
this.InitEncrypters(new string(nonceChars));
}
}
else
{
Debugger.Warning(string.Format("Messaging.onReceive: ignoring message of unknown type {0}", messageType));
}
return(Messaging.PACKET_HEADER_LENGTH + messageLength);
}
}
return(0);
}
/// <summary>
/// Called when the gateway receive a packet.
/// </summary>
internal int OnReceive(byte[] packet, int length)
{
if (length >= 7)
{
length -= 7;
int messageType = packet[1] | packet[0] << 8;
int messageLength = packet[4] | packet[3] << 8 | packet[2] << 16;
int messageVersion = packet[6] | packet[5] << 8;
if (length >= messageLength)
{
int encodingLength = messageLength;
byte[] encodingByteArray = new byte[messageLength];
Array.Copy(packet, 7, encodingByteArray, 0, messageLength);
if (this._receiveEncrypter != null)
{
byte[] encryptedByteArray = encodingByteArray;
byte[] decryptedByteArray = new byte[messageLength - this._receiveEncrypter.GetOverheadEncryption()];
this._receiveEncrypter.Decrypt(encryptedByteArray, decryptedByteArray, messageLength);
encodingByteArray = decryptedByteArray;
encodingLength -= this._receiveEncrypter.GetOverheadEncryption();
}
PiranhaMessage message = LogicMagicMessageFactory.Instance.CreateMessageByType(messageType);
if (message != null)
{
message.SetMessageVersion((short)messageVersion);
message.GetByteStream().SetByteArray(encodingByteArray, encodingLength);
try
{
message.Decode();
if (message.GetMessageType() == 20000)
{
ExtendedSetEncryptionMessage extendedSetEncryptionMessage = (ExtendedSetEncryptionMessage)message;
LogicMersenneTwisterRandom scrambler = new LogicMersenneTwisterRandom(0);
byte byte100 = 0;
for (int i = 0; i < 100; i++)
{
byte100 = (byte)scrambler.NextInt();
}
byte[] nonce = extendedSetEncryptionMessage.RemoveNonce();
string scrambledNonce = null;
for (int i = 0; i < nonce.Length; i++)
{
scrambledNonce += (char)(nonce[i] ^ (byte)(scrambler.NextInt() & byte100));
}
if (this._receiveEncrypter != null)
{
this._receiveEncrypter.Destruct();
this._receiveEncrypter = null;
}
if (this._sendEncrypter != null)
{
this._sendEncrypter.Destruct();
this._sendEncrypter = null;
}
this._receiveEncrypter = new RC4Encrypter(LogicMessagingConstants.RC4_KEY, scrambledNonce);
this._sendEncrypter = new RC4Encrypter(LogicMessagingConstants.RC4_KEY, scrambledNonce);
}
else
{
this.MessageManager.ReceiveMessage(message);
}
}
catch (Exception exception)
{
Logging.Error("Client::onReceive message decode exception, trace: " + exception);
}
Logging.Print("Client::sendMessage message " + message.GetType().Name + " received");
}
else
{
Logging.Warning("NetworkMessaging::onReceive Ignoring message of unknown type " + messageType);
}
return(messageLength + 7);
}
}
return(0);
}