/// <summary>
/// Sends a packet and retrieves the response
/// </summary>
/// <param name="packet"></param>
public void SendPacket(RconPacket packet)
{
try
{
Logger.Log(LogLevel.Verbose, "Sending command: '{0}'", packet.Command);
Send(packet.Command);
}
catch (Exception e)
{
Logger.Log(running ? LogLevel.Warning : LogLevel.Verbose, "SendPacket failed. ({0})", e.ToString());
return;
}
lastMessage = null;
DateTime start = DateTime.Now;
while (lastMessage == null)
{
if ((DateTime.Now - start).TotalMilliseconds < PacketTimeout)
{
Thread.Sleep(SLEEP);
}
else
{
Logger.Log(running ? LogLevel.Warning : LogLevel.Verbose, "Rcon packet timeout. (running {0})", packet.Command);
return;
}
}
packet.HandleResponse(lastMessage);
lastMessage = null;
}
/// <summary>
/// Sends a command to the server and retrieves the response
/// </summary>
/// <param name="command"></param>
/// <param name="p"></param>
/// <returns></returns>
public string SendCommand(string command, params string[] p)
{
RconPacket packet = new RconPacket(command + " " + string.Join(" ", p));
SendPacket(packet);
return(packet.Response);
}
public void TestThatFactoryMethodAndGetBytesFunctionCorrectly(int commandType, string command)
{
// Arrange
int commandId = GetRandomInt();
_mockCommand.Setup(s => s.CommandType).Returns(commandType);
_mockCommand.Setup(s => s.Text).Returns(command);
// Act
var packet1 = RconPacket.From(commandId, _mockCommand.Object);
using var writer = new BinaryWriter(stream);
writer.Write(packet1.GetBytes());
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using var reader = new BinaryReader(stream);
var packet2 = RconPacket.From(reader);
// Assert
Assert.That(packet1.Size == packet2.Size &&
packet1.CommandId == packet2.CommandId &&
packet1.PacketType == packet2.PacketType &&
packet1.Body == packet2.Body);
}
public void BuildPacketWithoutType()
{
// Arrange
var packet = new RconPacket(null, "password");
// Act
var buffer = packet.GetBytes();
}
public FakeChannel()
{
responsesMap = new Dictionary <PacketType, byte[]>
{
{ PacketType.ExecCommand, RconPacket.Create(PacketType.Response, "Command executed").ToBytes() },
{ PacketType.Auth, RconPacket.Create(PacketType.AuthResponse, "").ToBytes() }
};
}
/// <summary>
/// Sends a packet and retrieves the response
/// </summary>
/// <param name="packet"></param>
public void SendPacket(RconPacket packet)
{
string lastMessageTemp;
lock (rxLock)
{
lastMessage = null;
}
try
{
Logger.Log(LogLevel.Verbose, "Sending command: '{0}'", packet.Command);
Send(packet.Command);
}
catch (Exception e)
{
Logger.Log(running ? LogLevel.Warning : LogLevel.Verbose, "SendPacket failed. ({0})", e.ToString());
return;
}
DateTime start = DateTime.Now;
do
{
if ((DateTime.Now - start).TotalMilliseconds < PacketTimeout)
{
Thread.Sleep(SLEEP);
}
else
{
Logger.Log(LogLevel.Warning, "Rcon packet timeout. (running {0})", packet.Command);
return;
}
lock (rxLock)
{
lastMessageTemp = lastMessage;
}
} while (lastMessageTemp == null);
if (lastMessageTemp == STATUS_MESSAGE_SERVER_IS_BUSY)
{
Logger.Log(LogLevel.Verbose, "Server is busy - dropping rcon packet");
}
else
{
packet.HandleResponse(lastMessageTemp);
}
lock (rxLock)
{
lastMessage = null;
}
}
public void RconPacketTest()
{
RconPacket packet = new RconPacket(PacketType.ServerdataExeccommand, "Body");
Assert.IsTrue(packet.Id >= 0);
Assert.AreEqual(PacketType.ServerdataExeccommand, packet.Type);
Assert.AreEqual("Body", packet.Body);
Assert.AreEqual("Body".Length + 10, packet.Size);
Assert.AreEqual(packet.Size + 4, ((byte[])packet).Length);
//Assert.AreSame(new byte[] { 14, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 66, 111, 100, 121, 0, 0 }, (byte[])packet);
}
public void TestThatCommandTerminatorFactoryCreatesEmptyPacket()
{
// Arrange
int commandId = GetRandomInt();
// Act
var terminator = RconPacket.CommandTerminator(commandId);
// Assert
Assert.That(terminator.Body == string.Empty);
Assert.That(terminator.Size == 10);
}
public async Task SendValidCommand()
{
// Arrange
byte[] fakeResponse = new RconPacket(PacketType.ResponseValue, "command response").GetBytes();
var messenger = SetupMessenger(fakeResponse, true);
// Act
var response = await messenger.ExecuteCommandAsync("command");
// Assert
Assert.AreEqual("command response", response);
}
public void BuildPacketFromBytes()
{
// Arrange
var originalPacket = new RconPacket(PacketType.Auth, "password");
// Act
var buffer = originalPacket.GetBytes();
var parsedPacket = RconPacket.FromBytes(buffer);
// Assert
Assert.IsTrue(parsedPacket.Body.Equals(originalPacket.Body));
Assert.IsTrue(parsedPacket.Id.Equals(originalPacket.Id));
}
public void BuildPacketWithEmptyContent()
{
// Arrange
var packet = new RconPacket(PacketType.Auth, string.Empty);
// Act
var buffer = packet.GetBytes();
// Asert
Assert.IsNotNull(buffer);
Assert.IsTrue(buffer.Length == 14); // 14 fixed bytes
Assert.IsTrue(buffer[buffer.Length - 1] == 0x00 && buffer[buffer.Length - 2] == 0x00);
}
public void SendReceiveTest()
{
RconBase client = new RconBase();
client.Connect(Host, Port);
client.Authenticate(Password);
RconPacket request = new RconPacket(PacketType.ServerdataExeccommand, new Rcon.Commands.ListPlayers().ToString());
RconPacket response = client.SendReceive(request);
Assert.IsInstanceOfType(response, typeof(RconPacket));
Assert.AreEqual(request.Id, response.Id);
client.Disconnect();
}
public void BuildPacket()
{
// Arrange
var packet = new RconPacket(PacketType.Auth, "password");
// Act
var buffer = packet.GetBytes();
// Asert
Assert.IsNotNull(buffer);
Assert.IsTrue(buffer.Length == 22); // 14 fixed bytes + 8 bytes for "password" string encoding
Assert.IsTrue(buffer[0] == 0x12);
Assert.IsTrue(buffer[buffer.Length - 1] == 0x00 && buffer[buffer.Length - 2] == 0x00);
}
public void TestThatRconPacketIsConstructedProperlyWithFactoryMethod(int commandType, string command)
{
// Arrange
int commandId = GetRandomInt();
_mockCommand.Setup(s => s.CommandType).Returns(commandType);
_mockCommand.Setup(s => s.Text).Returns(command);
// Act
var packet = RconPacket.From(commandId, _mockCommand.Object);
// Assert
Assert.That(packet.Size == 10 + Encoding.UTF8.GetByteCount(command));
Assert.That(packet.CommandId == commandId);
Assert.That(packet.PacketType == commandType);
Assert.That(packet.Body == command);
}
private void HandleAuthentication(RconPacket rconPacket)
{
if (rconPacket.data["password"] == GameSettings.RconPassword)
{
authenticated = true;
SendLogHistory();
}
else
{
Logging.Log("Rcon password was incorrect");
SendPacket(RconPacketType.Error, new Dictionary <string, string>()
{
{ "errorMessage", "Password incorrect :(" }
});
localSocket.Close();
}
}
public void ConvertRconPacketToBytesShouldReturnValidRCONBuffer()
{
// Arrange
ProgressiveId.Seed(1);
var content = "test";
var packetType = PacketType.Auth;
var bufferLength = 18;
var packetLength = 14;
var packet = RconPacket.Create(packetType, content);
// Act
var buffer = packet.ToBytes();
// Asert
Assert.NotNull(buffer);
Assert.Equal(bufferLength, buffer.Length); // 12 headers bytes + 8 bytes for "password" string encoding + 1 ending
Assert.Equal(packetLength, BitConverter.ToInt32(buffer[0..4]));
private void HandleHandshake(RconPacket rconPacket)
{
Logging.Log("Received handshake from client.");
if (string.IsNullOrEmpty(GameSettings.RconPassword))
{
Logging.Log("Rcon authentication is disabled! Please enter a password in GameSettings if this is incorrect", Logging.Severity.Medium);
if (localSocket.ConnectionInfo.ClientIpAddress == "127.0.0.1")
{
authenticated = true;
}
else
{
Logging.Log("Unauthorized rcon connection attempt from non-local machine was blocked; set a password", Logging.Severity.Medium);
return;
}
}
}
public static void ShutdownServer(ArkServerInfo Server)
{
try
{
RconBase client = new RconBase();
client.Connect(Server.IPAddress, Int32.Parse(Server.RCONPort));
if (client.Connected)
{
client.Authenticate(Server.ServerPassword);
RconPacket request = new RconPacket(PacketType.ServerdataExeccommand, new Rcon.Commands.DoExit().ToString());
RconPacket response = client.SendReceive(request);
Console.WriteLine(response?.Body.Trim());
Methods.Log(Server, response?.Body.Trim());
}
client.Disconnect();
}
catch (Exception ex)
{
//Console.WriteLine(DateTime.Now + ": Exception occured when trying to send a Ark Server Shutdown Command. Exception: " + ex.Message);
Methods.Log(Server, DateTime.Now + ": Exception occured when trying to send a Ark Server Shutdown Command. Exception: " + ex.Message);
}
}
public static bool WorldSave(ArkServerInfo Server)
{
RconBase client = new RconBase();
client.Connect(Server.IPAddress, Int32.Parse(Server.RCONPort));
if (client.Connected)
{
client.Authenticate(Server.ServerPassword);
RconPacket request = new RconPacket(PacketType.ServerdataExeccommand, new Rcon.Commands.SaveWorld().ToString());
RconPacket response = client.SendReceive(request);
string stringResponse = response?.Body.Trim();
if (stringResponse.Contains("World Saved"))
{
Console.WriteLine(DateTime.Now + ": Server " + Server.Name + "- World Saved!");
Methods.Log(Server, DateTime.Now + ": Server " + Server.Name + "- World Saved!");
client.Disconnect();
return(true);
}
}
client.Disconnect();
return(false);
}
public static void GlobalNotification(ArkServerInfo Server, string message)
{
try
{
RconBase client = new RconBase();
client.Connect(Server.IPAddress, Int32.Parse(Server.RCONPort));
if (client.Connected)
{
client.Authenticate(Server.ServerPassword);
RconPacket request = new RconPacket(PacketType.ServerdataExeccommand, new Rcon.Commands.Broadcast(message).ToString());
RconPacket response = client.SendReceive(request);
//Console.WriteLine(DateTime.Now + ": Broadcast sent to " + Server.Name + " Server Message: " + message);
Methods.Log(Server, DateTime.Now + ": Broadcast sent to " + Server.Name + " Server Message: " + message);
}
client.Disconnect();
}
catch (Exception ex)
{
//Console.WriteLine(DateTime.Now + ": Exception occured when trying to send an Ark Server Global Notification. Exception: " + ex.Message);
Methods.Log(Server, DateTime.Now + ": Exception occured when trying to send an Ark Server Global Notification. Exception: " + ex.Message);
}
}
public Task SendAsync(ReadOnlyMemory <byte> payload)
{
var request = RconPacket.FromBytes(payload.ToArray());
switch (request.Type)
{
case PacketType.Auth:
pendingResponses.Add(RconPacket.Create(PacketType.Response, "").ToBytes());
pendingResponses.Add(RconPacket.Create(request.Body.Equals("valid") ? request.Id : -1, PacketType.AuthResponse, "").ToBytes());
break;
case PacketType.ExecCommand:
pendingResponses.Add(RconPacket.Create(PacketType.Response, "This will be a ve").ToBytes());
pendingResponses.Add(RconPacket.Create(PacketType.Response, "ry long message").ToBytes());
break;
case PacketType.Response:
pendingResponses.Add(RconPacket.Create(0, PacketType.Response, "").ToBytes());
pendingResponses.Add(RconPacket.Create(0, PacketType.Response, "\u0001").ToBytes());
break;
}
return(Task.CompletedTask);
}
void RecvThread()
{
while (sock.Connected)
{
try
{
RconPacket recvd = new RconPacket(this);
if (recvd.type == RconPacketType.SERVERDATA_AUTH)
{
if (recvd.string1 == rcon.password)
{
new RconPacket(this, RconPacketType.SERVERDATA_AUTH_RESPONSE, recvd.request_id, "", "").Send();
authed = true;
}
else
{
new RconPacket(this, RconPacketType.SERVERDATA_AUTH_RESPONSE, -1, "", "").Send();
}
}
else if (recvd.type == RconPacketType.SERVERDATA_EXECCOMMAND)
{
if (authed)
{
string response = "Unknown command or error!";
string cmd; string param;
string str = recvd.string1.Trim();
int splitter = str.IndexOf(' ');
if (splitter < 0)
{
cmd = str.ToLower();
param = "";
}
else
{
cmd = str.Remove(splitter).Trim().ToLower();
param = str.Substring(splitter + 1).Trim();
}
try
{
switch (cmd)
{
case "help":
response = "Commands: exec, stop, start, restart, kill, save, backup, status";
break;
case "exec":
Program.SendServerCommand(param);
response = "Ran command \"" + param + "\" on the server!";
break;
case "stop":
Program.StopServer();
response = "Server stopped!";
break;
case "start":
Program.StartServer();
response = "Server started!";
break;
case "restart":
Program.StopServer();
Program.StartServer();
response = "Server restarted!";
break;
case "kill":
Program.KillServer();
response = "Server KILL'd!";
break;
case "save":
Program.tmAutosave_Tick(null);
response = "Save initiated!";
break;
case "status":
//response = Program.serverStatus;
break;
case "say":
Program.SendServerMessage("RCon: " + param, '2');
Program.SendLogMsg("\"Console<9999><Console><RCon>\" say \"" + param + "\"");
break;
case "logaddress_add":
IPEndPoint ipep = __TryGetIp(param);
if (!Program.logToAddr.Contains(ipep)) Program.logToAddr.Add(ipep);
response = "Added " + param + " to log broadcast!";
Program.SendLogMsg("rcon from \"" + ip + "\": command \"logaddress_add \"" + param + "\"\"\n");
break;
case "logaddress_del":
IPEndPoint ipep2 = __TryGetIp(param);
if (Program.logToAddr.Contains(ipep2)) Program.logToAddr.Remove(ipep2);
response = "Removed " + param + " from log broadcast!";
Program.SendLogMsg("rcon from \"" + ip + "\": command \"logaddress_del \"" + param + "\"\"\n");
break;
case "logaddress_list":
response = "Log broadcast list:\n";
foreach (IPEndPoint ipep3 in Program.logToAddr)
{
response += ipep3.ToString() + "\n";
}
break;
case "logaddress_delall":
Program.logToAddr.Clear();
response = "Removed ALL IPs from log broadcast!";
break;
case "log":
response = "Usage: log < on | off >\ncurrently logging to: file, console, udp";
break;
default:
if (Program.commands.ContainsKey(cmd))
{
ply.request_id = recvd.request_id;
Program.commands[cmd].Run(ply, str.Split(new char[] { ' ' }));
response = "";
}
else
{
Program.SendServerCommand(str);
response = "Sent command to server commandline!";
}
break;
}
}
catch (Exception e) { response = "Command error: " + e.ToString(); }
if (response != null && response.Length > 0)
{
Program.AddRTLine(Color.Orange, "RCon from " + ip + ": " + recvd.string1 + "\r\n", true);
Program.AddRTLine(Color.Orange, "RCon response: " + response + "\r\n", true);
new RconPacket(this, RconPacketType.SERVERDATA_RESPONSE_VALUE, recvd.request_id, response + "\n", "").Send();
}
}
else
{
new RconPacket(this, RconPacketType.SERVERDATA_AUTH_RESPONSE, -1, "", "").Send();
}
}
}
catch { this.Disconnect(); return; }
Thread.Sleep(10);
}
}
private void HandleInput(RconPacket rconPacket)
{
Logging.Log($"Received input {rconPacket.data["input"]}");
}
private void HandleInputInProgress(RconPacket rconPacket)
{
SendSuggestions(rconPacket.data["input"]);
}
private void HandleRequestLogHistory(RconPacket rconPacket)
{
SendLogHistory();
}
public Task SendAsync(ReadOnlyMemory <byte> payload)
{
incomingRequests.Add(RconPacket.FromBytes(payload.ToArray()));
return(Task.CompletedTask);
}
