public RequestHandlerFactory(IContainerManager containerManager, IJobManager jobManager, Message.Type requestType, Request request)
{
if (containerManager == null)
{
throw new ArgumentNullException("containerManager");
}
if (jobManager == null)
{
throw new ArgumentNullException("jobManager");
}
if (requestType == default(Message.Type))
{
throw new ArgumentNullException("requestType");
}
if (request == null)
{
throw new ArgumentNullException("message");
}
this.containerManager = containerManager;
this.jobManager = jobManager;
this.requestType = requestType;
this.request = request;
}
// Token: 0x06000061 RID: 97 public abstract void PacketID(Message.Type val);
public void OnNetworkMessage(Message packet)
{
Message.Type type = packet.type;
if (type == Message.Type.Ready)
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)1)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: Client Ready");
return;
}
using (TimeWarning timeWarning = TimeWarning.New("ClientReady", (long)20))
{
try
{
this.ClientReady(packet);
}
catch (Exception exception)
{
this.Log(exception);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: Client Ready");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
switch (type)
{
case Message.Type.RPCMessage:
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)ConVar.Server.maxrpcspersecond)
{
Network.Net.sv.Kick(packet.connection, "Paket Flooding: RPC Message");
return;
}
using (timeWarning = TimeWarning.New("OnRPCMessage", (long)20))
{
try
{
this.OnRPCMessage(packet);
}
catch (Exception exception1)
{
this.Log(exception1);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: RPC Message");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
case Message.Type.EntityPosition:
case Message.Type.ConsoleMessage:
case Message.Type.Effect:
{
this.ProcessUnhandledPacket(packet);
return;
}
case Message.Type.ConsoleCommand:
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)ConVar.Server.maxcommandspersecond)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: Client Command");
return;
}
using (timeWarning = TimeWarning.New("OnClientCommand", (long)20))
{
try
{
ConsoleNetwork.OnClientCommand(packet);
}
catch (Exception exception2)
{
this.Log(exception2);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: Client Command");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
case Message.Type.DisconnectReason:
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)1)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: Disconnect Reason");
return;
}
using (timeWarning = TimeWarning.New("ReadDisconnectReason", (long)20))
{
try
{
this.ReadDisconnectReason(packet);
}
catch (Exception exception3)
{
this.Log(exception3);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: Disconnect Reason");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
case Message.Type.Tick:
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)ConVar.Server.maxtickspersecond)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: Player Tick");
return;
}
using (timeWarning = TimeWarning.New("OnPlayerTick", (long)20))
{
try
{
this.OnPlayerTick(packet);
}
catch (Exception exception4)
{
this.Log(exception4);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: Player Tick");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
default:
{
switch (type)
{
case Message.Type.GiveUserInformation:
{
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)1)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: User Information");
return;
}
using (timeWarning = TimeWarning.New("GiveUserInformation", (long)20))
{
try
{
this.OnGiveUserInformation(packet);
}
catch (Exception exception5)
{
this.Log(exception5);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: User Information");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
case Message.Type.GroupEnter:
case Message.Type.GroupLeave:
{
this.ProcessUnhandledPacket(packet);
return;
}
case Message.Type.VoiceData:
{
if (!packet.connection.isAuthenticated)
{
return;
}
if (packet.connection.GetPacketsPerSecond(packet.type) > (long)100)
{
Network.Net.sv.Kick(packet.connection, "Packet Flooding: Disconnect Reason");
return;
}
using (timeWarning = TimeWarning.New("OnPlayerVoice", (long)20))
{
try
{
this.OnPlayerVoice(packet);
}
catch (Exception exception6)
{
this.Log(exception6);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: Player Voice");
}
}
packet.connection.AddPacketsPerSecond(packet.type);
return;
}
case Message.Type.EAC:
{
using (timeWarning = TimeWarning.New("OnEACMessage", (long)20))
{
try
{
EACServer.OnMessageReceived(packet);
}
catch (Exception exception7)
{
this.Log(exception7);
Network.Net.sv.Kick(packet.connection, "Invalid Packet: EAC");
}
}
return;
}
default:
{
this.ProcessUnhandledPacket(packet);
return;
}
}
break;
}
}
}
public Message(Transceiver connection, Message.Type type, MessageContent contents, string creator)
{
this._origin = connection;
this._type = type;
this._content = contents;
}
public Unit Tell(object message, ProcessId sender, string inbox, Message.Type type, Message.TagSpec tag) => ProcessOp.IO(() => TellNoIO(message, sender, inbox, type, tag));
private void DiscoverType()
{
try
{
Logger.log("Attempting to discovering message type.", Logger.Verbosity.screaming);
XmlDocument document = new XmlDocument();
XmlElement element = null;
XmlNodeList list = null;
document.LoadXml(this._raw_message);
list = document.GetElementsByTagName("Message");
element = (XmlElement)list.Item(0);
string type = element.GetAttribute("type");
switch(type)
{
case "Plugins":
this._type = Message.Type.Plugins;
break;
case "Loop":
this._type = Message.Type.Loop;
break;
case "ServerToServer":
this._type = Message.Type.ServerToServer;
break;
case "UserToServer":
this._type = Message.Type.UserToServer;
break;
case "UserToServerPlugin":
this._type = Message.Type.UserToServerPlugin;
break;
case "UserToUser":
this._type = Message.Type.UserToUser;
break;
case "ServerToUser":
this._type = Message.Type.ServerToUser;
break;
case "ServerToUserPlugin":
this._type = Message.Type.ServerToUserPlugin;
break;
default:
this._type = Message.Type.Unknown;
break;
}
}
catch(Exception e)
{
this._type = Message.Type.Unknown;
}
Logger.log("Message type found: "+this.StringType(), Logger.Verbosity.screaming);
}
public Message(Message.Type type, byte[] data)
{
this.type = type;
this.data = data;
}
internal static RemoteMessageDTO CreateMessage(object message, ProcessId to, ProcessId sender, Message.Type type, Message.TagSpec tag) =>
new RemoteMessageDTO
{
Type = (int)type,
Tag = (int)tag,
To = to.Path,
RequestId = -1,
MessageId = Guid.NewGuid(),
Sender = sender.ToString(),
ReplyTo = sender.ToString(),
ContentType = message == null
? null
: message.GetType().AssemblyQualifiedName,
Content = message == null
? null
: JsonConvert.SerializeObject(message, ActorConfig.Default.JsonSerializerSettings)
};
internal static RemoteMessageDTO Create(object message, ProcessId to, ProcessId sender, Message.Type type, Message.TagSpec tag) =>
map(message as ActorRequest, req =>
req == null
? map(message as ActorResponse, res =>
res == null
? CreateMessage(message, to, sender, type, tag)
: CreateResponse(res, to, sender))
: CreateRequest(req, to, sender));
public async Task <bool> SaveMessageAsync(MessageModel messageModel, ApplicationUser user, Message.Type type)
{
var conversation = await _dbContext.Conversations.FindAsync(messageModel.ConversationId);
if (conversation == null)
{
return(false);
}
if (!_dbContext.ApplicationUserConversations
.Where(auc => auc.ConversationId == conversation.ConversationId)
.Any(auc => auc.UserId == user.Id))
{
return(false);
}
var msg = new Message()
{
ConversationId = messageModel.ConversationId,
MessageType = type,
SenderUserId = user.Id,
Content = messageModel.Content
};
await _dbContext.Messages.AddAsync(msg);
await _dbContext.SaveChangesAsync();
messageModel.Type = type;
messageModel.senderId = user.Id;
await _messagesHubContext.Clients
.Group(conversation.ConversationId.ToString())
.MessageSent(conversation.ConversationId, messageModel);
return(true);
}
