/// <summary>
/// Sends the specified message to server.
/// </summary>
internal void SendMessage(PiranhaMessage message)
{
message.Encode();
byte[] encodingByteArray = message.GetByteStream().RemoveByteArray();
int encodingLength = message.GetEncodingLength();
if (this._sendEncrypter != null)
{
byte[] decryptedByteArray = encodingByteArray;
byte[] encryptedByteArray = new byte[encodingLength + this._sendEncrypter.GetOverheadEncryption()];
this._sendEncrypter.Encrypt(decryptedByteArray, encryptedByteArray, encodingLength);
encodingLength += this._sendEncrypter.GetOverheadEncryption();
encodingByteArray = encryptedByteArray;
}
byte[] packet = new byte[7 + encodingLength];
Array.Copy(encodingByteArray, 0, packet, 7, encodingLength);
this.WriteHeader(message, packet, encodingLength);
this._networkGateway.Send(packet, encodingLength + 7);
Logging.Print("Client::sendMessage message " + message.GetType().Name + " sent");
}
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);
}
}
}
/// <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);
}
/// <summary>
/// Called when the connection receive a block of bytes.
/// </summary>
public void OnReceive(Connection connection)
{
byte[] buffer = this._connection.Buffer;
int length = buffer.Length;
if (length >= 7)
{
length -= 7;
int messageType = buffer[1] | (buffer[0] << 8);
int messageLength = buffer[4] | (buffer[3] << 8) | (buffer[2] << 16);
int messageVersion = buffer[6] | (buffer[5] << 8);
if (length >= messageLength)
{
this._connection.RemoveBlocking(messageLength + 7);
byte[] encodingByteArray = new byte[messageLength];
Array.Copy(buffer, 7, encodingByteArray, 0, messageLength);
if (this._receiveEncrypter != null)
{
byte[] encryptedByteArray = encodingByteArray;
byte[] decryptedByteArray = new byte[messageLength - this._receiveEncrypter.GetOverheadEncryption()];
Array.Copy(buffer, 7, encryptedByteArray, 0, messageLength);
this._receiveEncrypter.Decrypt(encryptedByteArray, decryptedByteArray, messageLength);
encodingByteArray = decryptedByteArray;
}
PiranhaMessage message = LogicMagicMessageFactory.CreateMessageByType(messageType);
if (message != null)
{
message.SetMessageVersion((short)messageVersion);
message.GetByteStream().SetByteArray(encodingByteArray, messageLength);
if (this._pepperState != 1)
{
if (this._pepperState == 2)
{
this._receiveMessageQueue.Enqueue(message);
}
message.Decode();
this._receiveMessageQueue.Enqueue(message);
Debugger.Log("Messaging::onReceive message " + message.GetType().Name + " received");
}
}
else
{
Debugger.Warning("Messaging::onReceive ignoring message of unknown type " + messageType);
}
if (length - messageLength >= 7)
{
this.OnReceive(connection);
}
}
}
}
