/// <summary>
/// Processes to send the specified message using the specified SocketAsyncEventArgs.
/// </summary>
private static void ProcessSend(PiranhaMessage message, SocketAsyncEventArgs args)
{
if (args.SocketError == SocketError.Success)
{
message.Offset += args.BytesTransferred;
if (message.Length + 7 > message.Offset)
{
if (message.Connection.IsConnected)
{
args.SetBuffer(message.Offset, (message.Length + 7 - message.Offset));
if (!message.Connection.Socket.SendAsync(args))
{
ServerConnection.ProcessSend(message, args);
}
}
else
{
ServerConnection.OnSendCompleted(null, args);
ServerConnection.Disconnect(message.Connection.Token.Args);
}
}
else
{
ServerConnection.OnSendCompleted(null, args);
}
}
else
{
ServerConnection.OnSendCompleted(null, args);
ServerConnection.Disconnect(message.Connection.Token.Args);
}
}
public void Send(PiranhaMessage message)
{
if (message.IsServerToClientMessage())
{
MessageHandler.EnqueueSend(message, this.m_clientConnection);
}
}
public async Task Send(PiranhaMessage message)
{
try
{
var asyncEvent = GetArgs;
await message.Encode();
message.Encrypt();
asyncEvent.SetBuffer(await message.BuildPacket(), 0, message.Length + 7);
asyncEvent.AcceptSocket = message.Device.Socket;
asyncEvent.RemoteEndPoint = message.Device.Socket.RemoteEndPoint;
asyncEvent.UserToken = message.Device.Token;
await StartSend(asyncEvent);
message.Dispose();
}
catch (Exception exception)
{
Disconnect(message.Device.Token.EventArgs);
Logger.Log(exception, Enums.LogType.Error);
}
}
/// <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>
/// Removes the <see cref="PiranhaMessage"/> instance.
/// </summary>
public PiranhaMessage RemovePiranhaMessage()
{
PiranhaMessage tmp = this._message;
this._message = null;
return(tmp);
}
/// <summary>
/// Sends the specified message.
/// </summary>
internal static void Send(PiranhaMessage message)
{
if (message.Connection.IsConnected)
{
SocketAsyncEventArgs writeEvent = ServerConnection.WritePool.Dequeue() ?? new SocketAsyncEventArgs
{
DisconnectReuseSocket = false
};
writeEvent.SetBuffer(message.ToArray(), message.Offset, message.Length + 7 - message.Offset);
writeEvent.AcceptSocket = message.Connection.Socket;
writeEvent.RemoteEndPoint = message.Connection.EndPoint;
writeEvent.UserToken = message.Connection.Token;
if (!message.Connection.Socket.SendAsync(writeEvent))
{
ServerConnection.ProcessSend(message, writeEvent);
}
}
else
{
ServerConnection.Disconnect(message.Connection?.Token?.Args);
}
}
/// <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 PiranhaMessage RemovePiranhaMessage()
{
PiranhaMessage message = this.m_piranhaMessage;
this.m_piranhaMessage = null;
return(message);
}
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);
}
public void Send(PiranhaMessage piranhaMessage)
{
if (!piranhaMessage.IsServerToClientMessage())
{
this.m_sendQueue.Enqueue(piranhaMessage);
}
}
private bool IsRequestPiranhaMessage(PiranhaMessage message)
{
int messageType = message.GetMessageType();
return(messageType == AskForAvatarProfileMessage.MESSAGE_TYPE ||
messageType == AskForAllianceDataMessage.MESSAGE_TYPE);
}
public void SendPiranhaMessage(PiranhaMessage piranhaMessage, int serverType)
{
foreach (AllianceSession session in this.m_onlineMembers.Values)
{
session.SendPiranhaMessage(piranhaMessage, serverType);
}
}
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;
}
}
}
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;
}
}
}
public void ReceiveMessage(PiranhaMessage message)
{
switch (message.GetMessageType())
{
case SendGlobalChatLineMessage.MESSAGE_TYPE:
this.OnSendGlobalChatLineMessageReceived((SendGlobalChatLineMessage)message);
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;
}
}
/// <summary>
/// Sends the specified message to server.
/// </summary>
internal void Send(PiranhaMessage message)
{
if (this._connection.IsConnected())
{
if (!message.IsServerToClientMessage())
{
this._sendMessageQueue.Enqueue(message);
this.OnWakeup(this._connection);
}
}
}
/// <summary>
/// Sends the pepper authentification message to server.
/// </summary>
internal void SendPepperAuthentification(ClientHelloMessage authMessage, PiranhaMessage pepperloginMessage, byte[] serverPublicKey)
{
this._pepperState = 1;
this._sendEncrypter = null;
this._receiveEncrypter = null;
this._pepperLoginMessage = pepperloginMessage;
this.Send(authMessage);
}
/// <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;
}
}
/// <summary>
/// Determines whether the specified <see cref="PiranhaMessage"/> is a client or server message and queues it accordingly.
/// </summary>
internal static void Enqueue(PiranhaMessage message)
{
if (message.IsClientToServerMessage)
{
MessageManager.ReceiveQueue.Enqueue(message);
MessageManager.ReceiveResetEvent.Set();
}
else
{
MessageManager.SendQueue.Enqueue(message);
MessageManager.SendResetEvent.Set();
}
}
/// <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>
/// Processes the specified buffer.
/// </summary>
internal void OnReceive(byte[] buffer)
{
if (buffer != null && this.IsConnected)
{
if (buffer.Length >= 7 && buffer.Length <= Constants.BufferSize)
{
Messaging.ReadHeader(buffer, out int id, out int length, out int version);
if ((id - 10000 < 10000) && (buffer.Length - 7 >= length))
{
using (ByteStream stream = new ByteStream(buffer.Skip(7).ToArray()))
{
PiranhaMessage message = LogicLifeMessageFactory.CreateMessageByType(id, this.Connection, stream);
if (message != null)
{
message.Type = (Message)id;
message.Length = length;
message.Version = (short)version;
message.Decrypt();
MessageManager.Enqueue(message);
}
if (!this.Connection.Token.Aborting)
{
this.Connection.Token.Packet.RemoveRange(0, length + 7);
if (buffer.Length - 7 - length >= 7)
{
this.OnReceive(stream.ReadBytes(buffer.Length - 7 - length));
}
}
}
}
else
{
Debugger.Error("The received buffer length is inferior the header length.");
this.Connection.Token.Buffer = null;
this.Connection.Token.Packet.Clear();
}
}
else
{
ServerConnection.Disconnect(this.Connection.Token.Args);
}
}
}
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;
}
}
/// <summary>
/// Forwards the specified <see cref="PiranhaMessage"/> to the service.
/// </summary>
public void SendPiranhaMessage(int serviceNodeType, PiranhaMessage message)
{
NetSocket socket = this._serviceNodeSockets[serviceNodeType];
if (socket != null)
{
if (message.GetEncodingLength() == 0)
{
message.Encode();
}
ForwardPiranhaMessage forwardPiranhaMessage = new ForwardPiranhaMessage();
forwardPiranhaMessage.SetPiranhaMessage(message);
NetMessageManager.SendMessage(socket, this.SessionId, forwardPiranhaMessage);
}
}
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 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()
});
}
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;
}
}
