/// <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; } }