예제 #1
0
        /// <summary>
        /// Broadcasts a <see cref="ChatMessagePacket"/> to all currently logged-in users.
        /// </summary>
        /// <param name="senderUuid">Sender's UUID</param>
        /// <param name="messageId">Message ID</param>
        /// <param name="message">Message content</param>
        /// <param name="timestamp">Timestamp</param>
        /// <param name="excludedConnectionIds">Array of connection IDs to be excluded from the broadcast</param>
        private void broadcastChatMessage(string senderUuid, string messageId, string message, DateTime timestamp, string[] excludedConnectionIds = null)
        {
            // Create and pack a ChatMessagePacket
            ChatMessagePacket packet = new ChatMessagePacket
            {
                Uuid      = senderUuid,
                MessageId = messageId,
                Message   = message,
                Timestamp = timestamp.ToTimestamp()
            };
            Any packedPacket = ProtobufPacketHelper.Pack(packet);

            // Get an array of connection IDs for each logged in user
            string[] connectionIds = userManager.GetConnections();

            // Remove the connection IDs to be excluded from the broadcast (if any)
            if (excludedConnectionIds != null)
            {
                connectionIds = connectionIds.Except(excludedConnectionIds).ToArray();
            }

            // Send it to each of the remaining connection IDs
            foreach (string connectionId in connectionIds)
            {
                // Try send the chat message
                if (!netServer.TrySend(connectionId, MODULE_NAME, packedPacket.ToByteArray()))
                {
                    RaiseLogEntry(new LogEventArgs("Failed to send ChatMessagePacket to connection " + connectionId.Highlight(HighlightType.ConnectionID), LogLevel.ERROR));
                }
            }
        }
예제 #2
0
파일: ClientChat.cs 프로젝트: Maatss/Phinix
        /// <summary>
        /// Handles incoming <see cref="ChatMessagePacket"/>s.
        /// </summary>
        /// <param name="connectionId">Original connection ID</param>
        /// <param name="packet">Incoming packet</param>
        private void chatMessagePacketHandler(string connectionId, ChatMessagePacket packet)
        {
            lock (messageHistoryLock)
            {
                // Store the message in chat history
                messageHistory.Add(new ClientChatMessage(packet.MessageId, packet.Uuid, packet.Message, packet.Timestamp.ToDateTime(), ChatMessageStatus.CONFIRMED));
            }

            OnChatMessageReceived?.Invoke(this, new ChatMessageEventArgs(packet.Message, packet.Uuid, packet.Timestamp.ToDateTime()));
        }
예제 #3
0
        /// <summary>
        /// Sends a message to the chat.
        /// </summary>
        /// <param name="message">Message</param>
        /// <exception cref="ArgumentException">Message cannot be null or empty</exception>
        public void Send(string message)
        {
            if (string.IsNullOrEmpty(message))
            {
                throw new ArgumentException("Message cannot be null or empty", nameof(message));
            }

            // Check if we aren't authenticated
            if (!authenticator.Authenticated)
            {
                RaiseLogEntry(new LogEventArgs("Cannot send chat message: Not authenticated"));

                return;
            }

            // Check if we aren't logged in
            if (!userManager.LoggedIn)
            {
                RaiseLogEntry(new LogEventArgs("Cannot send chat message: Not logged in"));

                return;
            }

            // Create a random message ID
            string messageId = Guid.NewGuid().ToString();

            // Create and store a chat message locally
            ClientChatMessage localMessage = new ClientChatMessage(messageId, userManager.Uuid, message);

            lock (messageHistoryLock)
            {
                messageHistory.Add(localMessage);
            }

            // Create and pack the chat message packet
            ChatMessagePacket packet = new ChatMessagePacket
            {
                SessionId = authenticator.SessionId,
                Uuid      = userManager.Uuid,
                MessageId = messageId,
                Message   = message
            };
            Any packedPacket = ProtobufPacketHelper.Pack(packet);

            // Send it on its way
            netClient.Send(MODULE_NAME, packedPacket.ToByteArray());
        }
예제 #4
0
        /// <summary>
        /// Sends a <see cref="ChatMessagePacket"/> to the user.
        /// </summary>
        /// <param name="connectionId">Destination connection ID</param>
        /// <param name="senderUuid">Sender's UUID</param>
        /// <param name="messageId">Message ID</param>
        /// <param name="message">Message content</param>
        /// <param name="timestamp">Timestamp</param>
        private void sendChatMessage(string connectionId, string senderUuid, string messageId, string message, DateTime timestamp)
        {
            // Create and pack our chat message packet
            ChatMessagePacket packet = new ChatMessagePacket
            {
                MessageId = messageId,
                Uuid      = senderUuid,
                Message   = message,
                Timestamp = timestamp.ToTimestamp()
            };
            Any packedPacket = ProtobufPacketHelper.Pack(packet);

            // Send it on its way
            if (!netServer.TrySend(connectionId, MODULE_NAME, packedPacket.ToByteArray()))
            {
                RaiseLogEntry(new LogEventArgs("Failed to send ChatMessagePacket to connection " + connectionId.Highlight(HighlightType.ConnectionID), LogLevel.ERROR));
            }
        }
예제 #5
0
        /// <summary>
        /// Handles incoming <see cref="ChatMessagePacket"/>s.
        /// </summary>
        /// <param name="connectionId">Original connection ID</param>
        /// <param name="packet">Incoming <see cref="ChatMessagePacket"/></param>
        private void chatMessagePacketHandler(string connectionId, ChatMessagePacket packet)
        {
            // Refuse packets from non-authenticated sessions
            if (!authenticator.IsAuthenticated(connectionId, packet.SessionId))
            {
                sendFailedChatMessageResponse(connectionId, packet.MessageId);

                // Stop here
                return;
            }

            // Refuse packets from non-logged in users
            if (!userManager.IsLoggedIn(connectionId, packet.Uuid))
            {
                sendFailedChatMessageResponse(connectionId, packet.MessageId);

                // Stop here
                return;
            }

            // Get a copy of the packet's original message ID
            string originalMessageId = packet.MessageId;

            // Generate a new, guaranteed-to-be-unique message ID since we can't trust clients
            string newMessageId = Guid.NewGuid().ToString();

            // Sanitise the message content
            string sanitisedMessage = TextHelper.SanitiseRichText(packet.Message);

            // Get the current time
            DateTime timestamp = DateTime.UtcNow;

            // Add the message to the message history
            addMessageToHistory(new ChatMessage(newMessageId, packet.Uuid, sanitisedMessage, timestamp));

            // Send a response to the sender
            sendChatMessageResponse(connectionId, true, originalMessageId, newMessageId, sanitisedMessage);

            // Broadcast the chat packet to everyone but the sender
            broadcastChatMessage(packet.Uuid, newMessageId, sanitisedMessage, timestamp, new[] { connectionId });
        }