/// <summary>
///
/// </summary>
/// <param name="message"></param>
protected virtual void PermissionLevelRequestHandler(IIncomingMessage message)
{
var key = message.AsString();
var extension = message.Peer.GetExtension <SecurityInfoPeerExtension>();
var currentLevel = extension.PermissionLevel;
var newLevel = currentLevel;
var permissionClaimed = false;
foreach (var entry in permissions)
{
if (entry.key == key)
{
newLevel = entry.permissionLevel;
permissionClaimed = true;
}
}
extension.PermissionLevel = newLevel;
if (!permissionClaimed && !string.IsNullOrEmpty(key))
{
// If we didn't claim a permission
message.Respond("Invalid permission key", ResponseStatus.Unauthorized);
return;
}
message.Respond(newLevel, ResponseStatus.Success);
}
protected virtual void OnGetUsersInChannelRequestHandler(IIncomingMessage message)
{
string responseMsg = string.Empty;
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
if (chatUser == null)
{
responseMsg = "Chat cannot identify you";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Unauthorized);
return;
}
var channelName = message.AsString();
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
responseMsg = "This channel is forbidden";
logger.Error(responseMsg);
// There's no such channel
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
var users = channel.Users.Select(u => u.Username);
message.Respond(users.ToBytes(), ResponseStatus.Success);
}
private void HandleLobbyMasterChangeMsg(IIncomingMessage message)
{
var masterUsername = message.AsString();
Data.GameMaster = masterUsername;
Listener?.OnMasterChanged(masterUsername);
}
private void HandleLobbyStatusTextChangeMsg(IIncomingMessage message)
{
var text = message.AsString();
Data.StatusText = text;
Listener?.OnLobbyStatusTextChanged(text);
}
protected virtual void OnPickUsernameRequestHandler(IIncomingMessage message)
{
try
{
if (!allowUsernamePicking)
{
throw new MstMessageHandlerException("Username picking is disabled", ResponseStatus.Failed);
}
var username = message.AsString();
if (username.Contains(" "))
{
throw new MstMessageHandlerException("Username cannot contain whitespaces", ResponseStatus.Failed);
}
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
if (chatUser != null)
{
throw new MstMessageHandlerException($"You're already identified as: {chatUser.Username}", ResponseStatus.Failed);
}
if (ChatUsers.ContainsKey(username))
{
throw new MstMessageHandlerException("There's already a user who has the same username", ResponseStatus.Failed);
}
chatUser = CreateChatUser(message.Peer, username);
if (!AddChatUser(chatUser))
{
throw new MstMessageHandlerException("Failed to add user to chat", ResponseStatus.Failed);
}
// Add the extension
message.Peer.AddExtension(chatUser);
// Send response
message.Respond(ResponseStatus.Success);
}
// If we got system exception
catch (MstMessageHandlerException e)
{
logger.Error(e.Message);
message.Respond(e.Message, e.Status);
}
// If we got another exception
catch (Exception e)
{
logger.Error(e.Message);
message.Respond(e.Message, ResponseStatus.Error);
}
}
/// <summary>
///
/// </summary>
/// <param name="member"></param>
/// <param name="message"></param>
public void ChatMessageHandler(LobbyMember member, IIncomingMessage message)
{
var text = message.AsString();
var messagePacket = new LobbyChatPacket()
{
Message = text,
Sender = member.Username
};
var msg = MessageHelper.Create((short)MstMessageCodes.LobbyChatMessage, messagePacket.ToBytes());
Broadcast(msg);
}
protected virtual void OnJoinChannelRequestHandler(IIncomingMessage message)
{
try
{
// Get user from peer
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
// If peer has no user
if (chatUser == null)
{
throw new MstMessageHandlerException("Chat cannot identify you", ResponseStatus.Unauthorized);
}
// Get channel name
var channelName = message.AsString();
// Trying to create channel with given name
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
throw new MstMessageHandlerException("This channel is forbidden", ResponseStatus.Failed);
}
if (!channel.AddUser(chatUser))
{
throw new MstMessageHandlerException("Failed to join a channel", ResponseStatus.Failed);
}
if (setFirstChannelAsLocal && chatUser.CurrentChannels.Count == 1)
{
chatUser.DefaultChannel = channel;
}
message.Respond(ResponseStatus.Success);
}
// If we got system exception
catch (MstMessageHandlerException e)
{
logger.Error(e.Message);
message.Respond(e.Message, e.Status);
}
// If we got another exception
catch (Exception e)
{
logger.Error(e.Message);
message.Respond(e.Message, ResponseStatus.Error);
}
}
private void HandleLobbyMemberLeftMsg(IIncomingMessage message)
{
var username = message.AsString();
Members.TryGetValue(username, out LobbyMemberData member);
if (member == null)
{
return;
}
Members.Remove(username);
Listener?.OnMemberLeft(member);
}
protected virtual void OnJoinChannelRequestHandler(IIncomingMessage message)
{
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
string responseMsg;
if (chatUser == null)
{
responseMsg = "Chat cannot identify you";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Unauthorized);
return;
}
var channelName = message.AsString();
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
responseMsg = "This channel is forbidden";
logger.Error(responseMsg);
// There's no such channel
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
if (!channel.AddUser(chatUser))
{
responseMsg = "Failed to join a channel";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
if (setFirstChannelAsLocal && chatUser.CurrentChannels.Count == 1)
{
chatUser.DefaultChannel = channel;
}
message.Respond(ResponseStatus.Success);
}
private void OnSaveProfileResponseCallback(ResponseStatus status, IIncomingMessage response)
{
Mst.Events.Invoke(MstEventKeys.hideLoadingInfo);
if (status == ResponseStatus.Success)
{
OnProfileSavedEvent?.Invoke();
logger.Debug("Your profile is successfuly updated and saved");
}
else
{
Mst.Events.Invoke(MstEventKeys.showOkDialogBox, new OkDialogBoxEventMessage(response.AsString()));
logger.Error(response.AsString());
}
}
protected virtual void OnLeaveChannelRequestHandler(IIncomingMessage message)
{
try
{
// Get user from peer
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
// If peer has no user
if (chatUser == null)
{
throw new MstMessageHandlerException("Chat cannot identify you", ResponseStatus.Unauthorized);
}
// Get channel name
var channelName = message.AsString();
// Trying to get channel by name
if (!ChatChannels.TryGetValue(channelName, out ChatChannel channel))
{
throw new MstMessageHandlerException("This channel does not exist", ResponseStatus.Failed);
}
// Remove user from channel
channel.RemoveUser(chatUser);
if (setLastChannelAsLocal && chatUser.CurrentChannels.Count == 1)
{
chatUser.DefaultChannel = chatUser.CurrentChannels.First();
}
message.Respond(ResponseStatus.Success);
}
// If we got system exception
catch (MstMessageHandlerException e)
{
logger.Error(e.Message);
message.Respond(e.Message, e.Status);
}
// If we got another exception
catch (Exception e)
{
logger.Error(e.Message);
message.Respond(e.Message, ResponseStatus.Error);
}
}
protected virtual void OnSetDefaultChannelRequestHandler(IIncomingMessage message)
{
try
{
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
// If peer has no user
if (chatUser == null)
{
throw new MstMessageHandlerException("Chat cannot identify you", ResponseStatus.Unauthorized);
}
var channelName = message.AsString();
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
throw new MstMessageHandlerException("This channel is forbidden", ResponseStatus.Failed);
}
// Add user to channel
channel.AddUser(chatUser);
// Set the property of default chat channel
chatUser.DefaultChannel = channel;
// Respond with a "success" status
message.Respond(ResponseStatus.Success);
}
// If we got system exception
catch (MstMessageHandlerException e)
{
logger.Error(e.Message);
message.Respond(e.Message, e.Status);
}
// If we got another exception
catch (Exception e)
{
logger.Error(e.Message);
message.Respond(e.Message, ResponseStatus.Error);
}
}
/// <summary>
/// Handles a request from game server to get a profile
/// </summary>
/// <param name="message"></param>
protected virtual void GameServerProfileRequestHandler(IIncomingMessage message)
{
if (!HasPermissionToEditProfiles(message.Peer))
{
message.Respond("Invalid permission level", ResponseStatus.Unauthorized);
return;
}
var userId = message.AsString();
profilesList.TryGetValue(userId, out ObservableServerProfile profile);
if (profile == null)
{
message.Respond(ResponseStatus.Failed);
return;
}
message.Respond(profile.ToBytes(), ResponseStatus.Success);
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
protected virtual async void GetAesKeyRequestHandler(IIncomingMessage message)
{
var extension = message.Peer.GetExtension <SecurityInfoPeerExtension>();
var encryptedKey = extension.AesKeyEncrypted;
if (encryptedKey != null)
{
logger.Debug("There's already a key generated");
// There's already a key generated
message.Respond(encryptedKey, ResponseStatus.Success);
return;
}
// Generate a random key
var aesKey = Mst.Helper.CreateRandomAlphanumericString(8);
var clientsPublicKeyXml = message.AsString();
// Deserialize public key
var sr = new System.IO.StringReader(clientsPublicKeyXml);
var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
var clientsPublicKey = (RSAParameters)xs.Deserialize(sr);
byte[] encryptedAes = await Task.Run(() =>
{
using (var csp = new RSACryptoServiceProvider())
{
csp.ImportParameters(clientsPublicKey);
encryptedAes = csp.Encrypt(Encoding.Unicode.GetBytes(aesKey), false);
// Save keys for later use
extension.AesKeyEncrypted = encryptedAes;
extension.AesKey = aesKey;
return(encryptedAes);
}
});
message.Respond(encryptedAes, ResponseStatus.Success);
}
/// <summary>
/// Fired when player requested access to this room
/// </summary>
/// <param name="message"></param>
private void ValidateRoomAccessRequestHandler(IIncomingMessage message)
{
var token = message.AsString();
var roomServer = Server as RoomServer;
logger.Debug($"Client {message.Peer.Id} requested access validation");
// Trying to validate room client connection access
//Mst.Server.Rooms.ValidateAccess(roomServer.CurrentRoomController.RoomId, token, (usernameAndPeerId, error) =>
//{
// if (usernameAndPeerId == null)
// {
// logger.Error(error);
// message.Peer.Disconnect("Invalid room access token");
// return;
// }
// // Let's get account info of the connected peer from master server
// Mst.Server.Auth.GetPeerAccountInfo(usernameAndPeerId.PeerId, (info, infoError) =>
// {
// if (info == null)
// {
// logger.Error(infoError);
// return;
// }
// logger.Debug($"Room got peer account info. {info}");
// // Create new room player info
// var roomUserExtension = new RoomUserPeerExtension(info.PeerId, info.Username, message.Peer, info.CustomOptions);
// // Add extension to peer
// message.Peer.AddExtension(roomUserExtension);
// // Inform all listeners
// OnPlayerJoinedEvent?.Invoke(roomUserExtension);
// });
// message.Respond(ResponseStatus.Success);
//});
}
protected virtual void OnSetDefaultChannelRequestHandler(IIncomingMessage message)
{
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
string responseMsg;
if (chatUser == null)
{
responseMsg = "Chat cannot identify you";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Unauthorized);
return;
}
var channelName = message.AsString();
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
responseMsg = "This channel is forbidden";
logger.Error(responseMsg);
// There's no such channel
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
// Add user to channel
channel.AddUser(chatUser);
// Set the property of default chat channel
chatUser.DefaultChannel = channel;
// Respond with a "success" status
message.Respond(ResponseStatus.Success);
}
protected virtual void OnLeaveChannelRequestHandler(IIncomingMessage message)
{
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
string responseMsg;
if (chatUser == null)
{
responseMsg = "Chat cannot identify you";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Unauthorized);
return;
}
var channelName = message.AsString().ToLower();
if (!ChatChannels.TryGetValue(channelName, out ChatChannel channel))
{
responseMsg = "This channel does not exist";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
channel.RemoveUser(chatUser);
if (setLastChannelAsLocal && chatUser.CurrentChannels.Count == 1)
{
chatUser.DefaultChannel = chatUser.CurrentChannels.First();
}
message.Respond(ResponseStatus.Success);
}
protected virtual void OnGetUsersInChannelRequestHandler(IIncomingMessage message)
{
try
{
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
// If peer has no user
if (chatUser == null)
{
throw new MstMessageHandlerException("Chat cannot identify you", ResponseStatus.Unauthorized);
}
var channelName = message.AsString();
var channel = GetOrCreateChannel(channelName);
if (channel == null)
{
throw new MstMessageHandlerException("This channel is forbidden", ResponseStatus.Failed);
}
var users = channel.Users.Select(u => u.Username);
message.Respond(users.ToBytes(), ResponseStatus.Success);
}
// If we got system exception
catch (MstMessageHandlerException e)
{
logger.Error(e.Message);
message.Respond(e.Message, e.Status);
}
// If we got another exception
catch (Exception e)
{
logger.Error(e.Message);
message.Respond(e.Message, ResponseStatus.Error);
}
}
protected virtual void OnPickUsernameRequestHandler(IIncomingMessage message)
{
string responseMsg;
if (!allowUsernamePicking)
{
responseMsg = "Username picking is disabled";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
var username = message.AsString();
if (username.Contains(" "))
{
responseMsg = "Username cannot contain whitespaces";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
var chatUser = message.Peer.GetExtension <ChatUserPeerExtension>();
if (chatUser != null)
{
responseMsg = $"You're already identified as: {chatUser.Username}";
logger.Error(responseMsg);
message.Respond(responseMsg);
return;
}
if (ChatUsers.ContainsKey(username.ToLower()))
{
responseMsg = "There's already a user who has the same username";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
chatUser = new ChatUserPeerExtension(message.Peer, username);
if (!AddChatUser(chatUser))
{
responseMsg = "Failed to add user to chat";
logger.Error(responseMsg);
message.Respond(responseMsg, ResponseStatus.Failed);
return;
}
// Add the extension
message.Peer.AddExtension(chatUser);
message.Respond(ResponseStatus.Success);
}
