private static void ProcessDepotCommand(byte[] data, DepotClient client) { var group = RdlCommandGroup.FromBytes(data); foreach (var cmd in group) { if (cmd.TypeName.ToUpper().Equals("MAPNAMES")) { client.Send(Depot.GetMapNames().ToBytes()); } else if (cmd.TypeName.ToUpper().Equals("MAPCHUNK")) { var mapName = cmd.GetArg <string>(0); var startX = cmd.GetArg <int>(1); var startY = cmd.GetArg <int>(2); var includeActors = cmd.GetArg <bool>(3); var result = Depot.GetMapChunk(mapName, startX, startY, includeActors).Tags; client.Send(Encoding.UTF8.GetBytes(result)); } else { client.Send(RdlTag.Empty.ToBytes()); } } }
/// <summary> /// Sends the specified command to the server to be executed. /// </summary> /// <param name="commands">The command to execute.</param> /// <param name="responseCallback">The CommunicatorResponseEventHandler to use for handling the /// response from this command execution. If this value is provided the Response event will not be raised.</param> public void Execute(RdlCommandGroup commands, CommunicatorResponseEventHandler responseCallback) { this.Buffer = commands.ToBytes(); this.AltCallback = responseCallback; this.CreateRequest(); this.Request.BeginGetRequestStream(new AsyncCallback(HttpCommunicator.BeginRequest), this); }
/// <summary> /// Sends the specified command to the server to be executed. /// </summary> /// <param name="commands">The command to execute.</param> /// <param name="responseCallback">The CommunicatorResponseEventHandler to use for handling the /// response from this command execution. If this value is provided the Response event will not be raised.</param> public void Execute(RdlCommandGroup commands, CommunicatorResponseEventHandler responseCallback) { _altResponse = responseCallback; // Create a message with the appropriate SOAPAction and asynchronously send it on the channel with the serialized Stock as the body of the envelope Message message = Message.CreateMessage(MessageVersion.Soap11, "Radiance.Contract.IGameServer/Process", commands.ToBytes()); Send(_channel, message); }
/// <summary> /// Sends the specified command to the server using the current CommunicationProtocol and provides an /// alternate handler for the server response. /// </summary> /// <param name="command">The CommandTag to send to the server.</param> /// <param name="serverResponseCallback">The CommunicatorResponseEventHandler that will handle the /// response from this command.</param> public void SendCommand(RdlCommand command, CommunicatorResponseEventHandler serverResponseCallback) { RdlCommandGroup group = new RdlCommandGroup(new RdlCommand[] { command }); group.AuthKey = this.AuthKey; group.AuthKeyType = this.AuthKeyType; this.Init(); _communicator.Execute(group, serverResponseCallback); }
/// <summary> /// Processes commands in the context of the virtual world. /// </summary> /// <param name="requestHandler">The ICommunicationHandler processing the request from the client.</param> /// <param name="commands">The commands to process.</param> /// <returns>The IClient instance of the current requestor.</returns> public IClient ProcessCommands(ICommunicationHandler requestHandler, RdlCommandGroup commands, Guid sessionId, string address) { bool addClient = false; IClient client = null; if (commands.Count > 0) { if (!String.IsNullOrEmpty(commands.AuthKey)) { AuthKey key = AuthKey.Get(commands.AuthKey); if (this.ValidateAuthKey(key)) { // Clients are stored with the UserName of the current user as the key. This // should prevent a user from playing multiple characters at the same time unless // they have multiple user names, which violates the TOS. if (!this.Clients.ContainsKey(key.SessionId)) { client = requestHandler.CreateClient(key.SessionId); client.Address = address; client.UserName = key.UserName; addClient = true; } else { client = this.Clients[key.SessionId]; } if (client != null) { //client.LastHeartbeatDate = DateTime.Now; client.AuthKey = key; } } } else { // New client will implement the LoginCommandHandler. client = requestHandler.CreateClient(sessionId); client.Address = address; addClient = true; } if (addClient) { this.Clients.Add(client); this.World.Provider.CreateSession(client, client.SessionId.ToString()); Logger.LogDebug("SERVER: New client connected from: {0}", client.SessionId.ToString()); } if (client != null) { ProcessCommands(client, commands); } } return(client); }
/// <summary> /// Validates that the specified command can be executed by this handler. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The commands being executed.</param> /// <returns>True if the commands can be executed by the current handler; otherwise false.</returns> protected override bool ValidateCommands(Server server, RdlCommandGroup commands) { if (this.Client.AuthKey.ID == 0) { this.Client.Handler = new UserCommandHandler(this.Client); this.Client.Handler.ProcessCommands(server, commands); return(false); } return(this.Client.Player != null && this.Client.Player.UserName == this.Client.AuthKey.UserName); }
/// <summary> /// Processes the commands in the RdlCommandGroup. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The RdlCommandGroup containing the commands to process.</param> public override void ProcessCommands(Server server, RdlCommandGroup commands) { if (this.ValidateCommands(server, commands)) { int count = commands.Count; for (int i = 0; i < count; i++) { this.ProcessCommand(server, commands[i], this.Client.Context); } } }
public void Process(byte[] data) { var session = OperationContext.Current.GetPollingDuplexSession(); Logger.LogDebug("SERVER: Recieved data from {0} on Thread [ {1} ]", session.SessionId, Thread.CurrentThread.ManagedThreadId); var commands = RdlCommandGroup.FromBytes(data); if (commands != null && commands.Count > 0) { Game.Server.ProcessCommands(this, commands, new Guid(session.SessionId), session.Address); } }
/// <summary> /// Processes commands in the context of the virtual world. /// </summary> /// <param name="client">The IClient processing the request.</param> /// <param name="commands">The commands to process.</param> /// <returns>The IClient instance of the current requestor.</returns> public IClient ProcessCommands(IClient client, RdlCommandGroup commands) { if (!(client.Handler is LoginCommandHandler)) { client.LastCommandGroup = commands; } bool processCommands = this.World.IsOnline; if (!processCommands) { processCommands = this.World.Provider.ValidateRole(client.UserName, RoleNames.God); } if (processCommands) { if (this.World.EnableCommandLogging) { if (!(client.Handler is LoginCommandHandler)) { Lionsguard.Logger.LogCommand("CMD LOG: SessionId: {0}, UserName: {1}, Commands: {2}", client.SessionId, client.UserName, commands.ToString()); } } // TODO: Spam filter, record the commands to this client, if the same command chat // command is sent more than twice in a row then abandon this command group. // Queue commands. lock (_receivedPackets) { Logger.LogDebug("SERVER: Queue Commands: {0}, for Client: {1}", commands, client.UserName); _receivedPackets.Enqueue(new ClientPacket { Client = client, Commands = commands }); } // Update client session. this.World.Provider.UpdateSession(client); this.Signal(); } else { client.Context.Add(new RdlErrorMessage(SR.WorldOffline(this.World.Name))); // Send down a command to refresh the web page where the client sits so // it will redirect to the app offline page. client.Context.Add(new RdlCommand("EXIT")); } return(client); }
/// <summary> /// Processes the commands in the RdlCommandGroup. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The RdlCommandGroup containing the commands to process.</param> public override void ProcessCommands(Server server, RdlCommandGroup commands) { if (String.IsNullOrEmpty(commands.AuthKey)) { // If authkey is null but a login command exists then process the login command. // Check for a login command. var cmds = commands.Where(c => c.TypeName == KnownCommands.Login || c.TypeName == KnownCommands.Heartbeat || c.TypeName == KnownCommands.ForgotPassword || c.TypeName == KnownCommands.SignUp); if (cmds != null) { foreach (var cmd in cmds) { CommandManager.ProcessCommand(server, cmd, this.Client); } //string username = cmd.GetArg<string>(0); //AuthKey authKey = server.World.Provider.AuthenticateUser(username, cmd.GetArg<string>(1)); //RdlAuthKey user = new RdlAuthKey(authKey.ToString(), authKey.Type.ToString()); //this.Client.Context.Add(user); //if (!String.IsNullOrEmpty(authKey.ToString())) //{ // this.Client.Handler = new UserCommandHandler(this.Client); // this.Client.UserName = username; // this.Client.AuthKey = authKey; // //if (!server.Clients.ContainsKey(username)) // //{ // //// // Expire the current client. // //// server.Clients[username].Expire(); // //// // Reset the current client. // //// server.Clients[username] = this.Client; // ////} // ////else // ////{ // // server.Clients.Add(this.Client); // //} //} } } else { this.Client.Handler = new UserCommandHandler(this.Client); this.Client.Handler.ProcessCommands(server, commands); } }
public string Process(string data) { var response = String.Empty; var client = Game.Server.ProcessCommands(this, RdlCommandGroup.FromString(data), Guid.NewGuid(), OperationContext.Current.Channel.LocalAddress.ToString()); if (client != null) { var tags = new RdlTagCollection(); RdlTag tag; while (client.Context.Read(out tag)) { tags.Add(tag); } response = tags.ToString(); } return(response); }
/// <summary> /// Processes the packet data for a connected client. /// </summary> /// <param name="data">The packet data to process.</param> public void Process(byte[] data) { Logger.LogDebug("SERVER: DuplexService.Process Entered."); ThreadPool.QueueUserWorkItem((o) => { var info = (SessionInfo)o; Logger.LogDebug("SERVER: Executing DuplexService.Process on Thread {0}", Thread.CurrentThread.ManagedThreadId); var commands = RdlCommandGroup.FromBytes(info.Data); if (commands.Count > 0) { var client = Game.Server.Clients.Where(c => c.SessionId.ToString().Equals(info.Session.SessionId)).FirstOrDefault(); if (client == null) { Game.Server.ProcessCommands(this, commands, info.Session); } else { Game.Server.QueueRequest(this, commands, info.Session); } } Logger.LogDebug("SERVER: Completed DuplexService.Process."); }, new SessionInfo { Data = data, Session = OperationContext.Current.GetPollingDuplexSession() }); //var commands = RdlCommandGroup.FromBytes(data); //if (commands.Count > 0) //{ // var session = OperationContext.Current.GetPollingDuplexSession(); // var client = Game.Server.Clients.Where(c => c.SessionId.ToString().Equals(session.SessionId)).FirstOrDefault(); // if (client == null) // { // Game.Server.ProcessCommands(this, commands, OperationContext.Current.GetPollingDuplexSession()); // } // else // { // Game.Server.QueueRequest(this, commands, OperationContext.Current.GetPollingDuplexSession()); // } //} Logger.LogDebug("SERVER: DuplexService.Process Exited."); }
/// <summary> /// Validates that the specified command can be executed by this handler. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The commands being executed.</param> /// <returns>True if the commands can be executed by the current handler; otherwise false.</returns> protected override bool ValidateCommands(Server server, RdlCommandGroup commands) { if (this.Client.AuthKey.ID > 0) { this.Client.Handler = new PlayerCommandHandler(this.Client); this.Client.Handler.ProcessCommands(server, commands); return(false); } RdlCommand cmd = commands.Where(c => c.TypeName == "ADMINBUILD").FirstOrDefault(); if (cmd != null) { this.Client.Handler = new AdminCommandHandler(this.Client); this.Client.Handler.ProcessCommands(server, commands); return(false); } return(true); }
/// <summary> /// Validates that the specified command can be executed by this handler. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The commands being executed.</param> /// <returns>True if the commands can be executed by the current handler; otherwise false.</returns> protected override bool ValidateCommands(Server server, RdlCommandGroup commands) { return(true); }
public void ProcessRequest(HttpContext context) { var response = new List <byte>(); try { // Read the bytes from the request stream and create a Message from it. var buffer = new byte[context.Request.ContentLength]; context.Request.InputStream.Read(buffer, 0, context.Request.ContentLength); if (buffer != null && buffer.Length > 0) { var perenthiaSessionId = context.Request.Headers.Get(HttpHeaders.RadianceSessionIdHeaderKey); Guid sessionId; if (!Lionsguard.Util.GuidTryParse(perenthiaSessionId, out sessionId)) { sessionId = Guid.NewGuid(); } IClient client = null; var waitForTags = false; var commands = RdlCommandGroup.FromBytes(buffer); if (commands.Count == 1 && commands[0].TypeName == RdlCommand.Heartbeat.TypeName) { Game.Server.Clients.TryGetClient(sessionId, out client); } else { waitForTags = true; client = Game.Server.ProcessCommands(this, commands, sessionId, context.Request.UserHostAddress); } if (client != null) { // Wait for the client to get some tags. if (waitForTags) { while (client.Context.Count == 0) { _waitHandle.WaitOne(TimeSpan.FromSeconds(1)); } } RdlTag tag; while (client.Context.Read(out tag)) { response.AddRange(tag.ToBytes()); } Logger.LogDebug("SERVER: Sending {0} bytes to the client.", response.Count); } } } catch (Exception ex) { #if DEBUG throw ex; #else Lionsguard.Log.Write(ex.ToString(), true); #endif } context.Response.ContentType = "binary/octet-stream"; if (response.Count > 0) { context.Response.BinaryWrite(response.ToArray()); } else { context.Response.Write(String.Empty); } }
private static void OnBeginReceiveComplete(IAsyncResult ar) { var context = (SocketMessageContext)ar.AsyncState; int bytesReceived = 0; try { // Complete the call. bytesReceived = context.Socket.EndReceive(ar); } catch (SocketException) { // Disconnect the current client. context.Socket.Close(); if (context.Client != null) { context.Client.Expire(); } return; } catch (ObjectDisposedException) { if (context.Client != null) { context.Client.Expire(); } return; } try { if (bytesReceived > 0) { context.PacketData.AddRange(context.Buffer.Take(bytesReceived)); if (context.PacketData.Count >= 4) { int index = 0; // Convert the current packet data into a byte array. byte[] data = context.PacketData.ToArray(); bool readComplete = false; while (!readComplete) { // Get the length of the bytes to process. Length does do not include // the 4 bytes required for the actual length int value itself. int length = BitConverter.ToInt32(data, index); // Advance the index 4 bytes to account for the length value. index += 4; if (data.Length >= length + 4) // Account for the length value { byte[] buffer = new byte[length]; Array.Copy(data, index, buffer, 0, length); // Completed adding packet data, create the reader and allow the network to process the packet. Game.Server.ProcessCommands(context.Client, RdlCommandGroup.FromBytes(buffer)); index += length; if (index >= data.Length) { context.PacketData.Clear(); readComplete = true; } } else { readComplete = true; } } } } context.BeginReceive(); } catch (SocketException) { context.Socket.Close(); if (context.Client != null) { context.Client.Expire(); } } }
/// <summary> /// Validates that the specified command can be executed by this handler. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The commands being executed.</param> /// <returns>True if the commands can be executed by the current handler; otherwise false.</returns> protected abstract bool ValidateCommands(Server server, RdlCommandGroup commands);
/// <summary> /// Processes the commands in the RdlCommandGroup. /// </summary> /// <param name="server">The current server instance.</param> /// <param name="commands">The RdlCommandGroup containing the commands to process.</param> public abstract void ProcessCommands(Server server, RdlCommandGroup commands);
/// <summary> /// Sends the specified command to the server to be executed. /// </summary> /// <param name="commands">The command to execute.</param> /// <param name="responseCallback">The CommunicatorResponseEventHandler to use for handling the /// response from this command execution. If this value is provided the Response event will not be raised.</param> public void Execute(RdlCommandGroup commands, CommunicatorResponseEventHandler responseCallback) { this.AltCallback = responseCallback; this.Send(commands.ToBytes()); }
/// <summary> /// Sends the specified command to the server to be executed. /// </summary> /// <param name="commands">The command to execute.</param> public void Execute(RdlCommandGroup commands) { Execute(commands, null); }