public void ProcessCommand(CommandType type)
{
try
{
switch (type)
{
/*case CommandType.SHOW_WINDOWS_KEYBOARD:
* ShowWindowsKeyboard();
* break;*/
case CommandType.REBOOT_PC:
serverHandler.DisconnectClient();
serverHandler.Stop();
Process.Start("shutdown", "/r /t 0");
break;
case CommandType.TURN_OFF_PC:
serverHandler.DisconnectClient();
serverHandler.Stop();
Process.Start("shutdown", "/s /t 0");
break;
}
}
catch
{
LdpLog.Error("Executing command error.");
}
}
public void Handle(LdpPacket packet)
{
switch (packet.Type)
{
case PacketType.SCREEN_REQUEST:
/*ThreadPool.QueueUserWorkItem(new WaitCallback((s) =>
* {
* GetScreen();
* }));*/
//if (ScreenThread != null && ScreenThread.IsAlive)
//ScreenThread.Join();
ScreenThread = new Thread(() => GetScreen());
ScreenThread.Start();
break;
case PacketType.DISCONNECT_REQUEST:
var result = packet.DisconnectRequest;
switch (result.Type)
{
case DisconnectionType.FROM_SCREEN_THREAD:
interruptGrabbing = false;
LdpLog.Info("Exiting screen thread.");
serverHandler.GetListenerChannel.RemoveListener(this);
break;
}
break;
}
}
private void InitGrabber()
{
try
{
this.pixelFormat = PixelFormat.Format32bppRgb;
boundsRect = new System.Drawing.Rectangle(0, 0, WIDTH, HEIGHT);
var format = SharpDX.Direct3D9.Format.A8R8G8B8;
SharpDX.Direct3D9.PresentParameters present_params = new SharpDX.Direct3D9.PresentParameters();
present_params.Windowed = true;
present_params.BackBufferFormat = format;
present_params.SwapEffect = SharpDX.Direct3D9.SwapEffect.Discard;
present_params.BackBufferWidth = WIDTH;
present_params.BackBufferHeight = HEIGHT;
dx9Device = new SharpDX.Direct3D9.Device(new SharpDX.Direct3D9.Direct3D(),
0,
SharpDX.Direct3D9.DeviceType.Hardware,
IntPtr.Zero,
SharpDX.Direct3D9.CreateFlags.HardwareVertexProcessing,
present_params);
dx9Device.SetRenderState(RenderState.CullMode, Cull.None);
dx9Device.SetRenderState(RenderState.Lighting, false);
dx9Device.SetRenderState(RenderState.AntialiasedLineEnable, false);
}
catch (SharpDX.SharpDXException dxe)
{
LdpLog.Error("SharpDX InitializeDX9\n" + dxe.Message);
}
catch (Exception ex)
{
LdpLog.Error("InitializeDX9\n" + ex.Message);
}
}
public void SetPassword(string password)
{
Settings.Default.Password = password;
Settings.Default.Save();
string success = "User settings: password updated successfully.";
LdpLog.Info(success);
}
private void StartListening()
{
while (client_connected)
{
Handle();
}
LdpLog.Info("Listener thread stopped.");
}
public LdpPacketListener()
{
serverHandler = LdpServer.GetInstance();
client_connected = true;
listening_thread = new Thread(() => StartListening());
listening_thread.Start();
LdpLog.Info("Listener thread started.");
}
public void RemoveListener(ILdpPacketHandler listener)
{
if (listeners.Contains(listener))
{
listener.Dispose();
listeners.Remove(listener);
LdpLog.Info(String.Format("Listener removed: {0}.", listener.GetType()));
listener = null;
}
}
private void PrintServerStarting()
{
string text = "Try to use one of the following IP:\n";
foreach (var ip in GetLocalIpAddressList())
{
text += ip + "\n";
}
LdpLog.Info(text);
LdpLabelStatus.GetInstance().StateText = text;
}
public void Start(int port)
{
try
{
this.PORT = port;
base.StartServer(port);
}
catch (Exception ex)
{
LdpLog.Error("Starting server error:\n" + ex.Message);
Stop();
}
}
private void GetScreen()
{
lock (LOCK)
{
try
{
Rectangle bounds = Rectangle.Empty;
interruptGrabbing = false;
while (!interruptGrabbing)
{
nextScreen = screenGrabber.GetScreenShot();
if (nextScreen == null)
{
break;
}
bounds = LdpScreenProcessingUtils.GetBoundingBoxForChanges(nextScreen, prevScreen);
if (bounds != Rectangle.Empty)
{
interruptGrabbing = true;
CheckRectangleBounds(ref bounds);
difference = LdpScreenProcessingUtils.CopyRegion(nextScreen, bounds);
origData = LdpScreenProcessingUtils.ImageToByteArray(difference);
baseLenght = origData.Length;
compressed = LZ4Codec.Encode(origData, 0, baseLenght);
rect = LdpRectangle.CreateBuilder();
rect.Left = bounds.Left;
rect.Top = bounds.Top;
rect.Right = bounds.Right;
rect.Bottom = bounds.Bottom;
SendScreenResponse(compressed, baseLenght, rect);
difference.Dispose();
difference = null;
rect = null;
origData = null;
compressed = null;
}
prevScreen = nextScreen;
}
}
catch (Exception ex)
{
LdpLog.Error("GetScreen thrown:\n" + ex.Message);
}
}
}
public void RemoveListeners()
{
if (listeners != null && listeners.Count != 0)
{
for (int i = listeners.Count - 1; i >= 0; i--)
{
LdpLog.Info(String.Format("Listener removed: {0}.",
listeners[i].GetType()));
listeners[i].Dispose();
listeners[i] = null;
listeners.Remove(listeners[i]);
}
}
}
protected override void Handle()
{
try
{
using (var stream = new NetworkStream(serverHandler.GetSocketChannel))
{
var packet = LdpPacket.ParseDelimitedFrom(stream);
ProcessPacket(packet);
//base - notify to all subscribers
NotifyToAllListeners(packet);
//stream.Close();
}
}
catch (IOException ioexc)
{
string error =
String.Format(@"LdpPacketListener IOException:
Handle() method throw:\n{0}.", ioexc.Message);
LdpLog.Error(error);
Restart();
}
catch (SocketException sockexc)
{
switch (sockexc.ErrorCode)
{
case CLIENT_DISCON_ERROR_CODE:
LdpLog.Info("LdpPacketListener: client disconnected.");
Restart();
break;
default:
string error =
String.Format(@"LdpPacketListener SocketException:
Handle() method throw:\n{0}.", sockexc.Message);
LdpLog.Error(error);
Restart();
break;
}
}
catch (Exception ex)
{
string error =
String.Format(@"LdpPacketListener Exception:
Handle() method throw:\n{0}.", ex.Message);
LdpLog.Error(error);
Restart();
}
}
protected void DisconntectClientFromServer()
{
if (clientSocket != null && clientSocket.Connected)
{
try
{
var factory = new LdpProtocolPacketFactory();
var list = packetListener.GetListenersList;
LdpDisconnectRequest disconnectPacket = null;
LdpPacket packet = null;
const int TIMEOUT = 100;
if (list != null && list.Count != 0)
{
foreach (var item in list)
{
if (item is LdpRemoteDesktopSender)
{
disconnectPacket = factory
.SetDisconnectRequest(DisconnectionType.FROM_SCREEN_THREAD);
packet = factory.BuildPacket(disconnectPacket);
packetSender.Send(packet);
Thread.Sleep(TIMEOUT);
break;
}
else if (item is LdpRemoteVolumeSender)
{
disconnectPacket = factory
.SetDisconnectRequest(DisconnectionType.FROM_VOLUME_THREAD);
packet = factory.BuildPacket(disconnectPacket);
packetSender.Send(packet);
Thread.Sleep(TIMEOUT);
break;
}
}
}
disconnectPacket = factory
.SetDisconnectRequest(DisconnectionType.FROM_SERVER);
packet = factory.BuildPacket(disconnectPacket);
packetSender.Send(packet);
disconnectPacket = null;
packet = null;
}
catch (Exception exc)
{
LdpLog.Error("DisconntectClient error.\n" + exc.Message);
}
}
}
private void InitGrabber()
{
try
{
this.pixelFormat = PixelFormat.Format32bppRgb;
boundsRect = new System.Drawing.Rectangle(0, 0, WIDTH, HEIGHT);
uint numAdapter = 0; // # of graphics card adapter
uint numOutput = 0; // # of output device (i.e. monitor)
// create device and factory
dx11Device = new SharpDX.Direct3D11.Device(SharpDX.Direct3D.DriverType.Hardware);
dx11Factory = new Factory1();
dx11Output = new Output1(dx11Factory.Adapters1[numAdapter].Outputs[numOutput].NativePointer);
// creating CPU-accessible texture resource
dx11Texture2Ddescr = new SharpDX.Direct3D11.Texture2DDescription();
dx11Texture2Ddescr.CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.Read;
dx11Texture2Ddescr.BindFlags = SharpDX.Direct3D11.BindFlags.None;
dx11Texture2Ddescr.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm;
dx11Texture2Ddescr.Height = HEIGHT;
dx11Texture2Ddescr.Width = WIDTH;
dx11Texture2Ddescr.OptionFlags = SharpDX.Direct3D11.ResourceOptionFlags.None;
dx11Texture2Ddescr.MipLevels = 1;
dx11Texture2Ddescr.ArraySize = 1;
dx11Texture2Ddescr.SampleDescription.Count = 1;
dx11Texture2Ddescr.SampleDescription.Quality = 0;
dx11Texture2Ddescr.Usage = SharpDX.Direct3D11.ResourceUsage.Staging;
dx11ScreenTexture = new SharpDX.Direct3D11.Texture2D(dx11Device, dx11Texture2Ddescr);
// duplicate output stuff
dx11DuplicatedOutput = dx11Output.DuplicateOutput(dx11Device);
}
catch (SharpDX.SharpDXException dxe)
{
string error = "Directx 11 initializer error.\n" + dxe.Message;
LdpLog.Error(error);
MessageBox.Show(error, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception ex)
{
string error = "Directx 11 initializer error.\n" + ex.Message;
LdpLog.Error(error);
MessageBox.Show(error, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
protected void StopServer()
{
try
{
Cleanup();
if (serverSocket != null)
{
LdpLog.Info("Server shutdown.");
if (clientSocket != null && clientSocket.Connected)
{
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
clientSocket.Dispose();
}
serverSocket.Close();
serverSocket.Dispose();
}
}
catch (SocketException sockexc)
{
LdpLog.Error("Server shutdown thrown:\n" + sockexc.Message);
}
catch (Exception ex)
{
LdpLog.Error("Server shutdown thrown:\n" + ex.Message);
}
finally
{
clientSocket = null;
serverSocket = null;
}
try
{
if (serverThread != null)
{
serverThread.Abort();
serverThread = null;
}
}
catch { LdpLog.Error("ServerThread interrupted."); }
GC.Collect();
}
private Bitmap GetDX9ScreenShot()
{
try
{
screenShot = null;
screenShot = new System.Drawing.Bitmap(WIDTH, HEIGHT, pixelFormat);
dx9ScreenSurface = SharpDX.Direct3D9.Surface.CreateOffscreenPlain(
dx9Device,
WIDTH,
HEIGHT,
SharpDX.Direct3D9.Format.A8R8G8B8,
Pool.SystemMemory);
dx9Device.GetFrontBufferData(0, dx9ScreenSurface);
dx9Map = dx9ScreenSurface.LockRectangle(LockFlags.None);
bmpData = screenShot.LockBits(boundsRect,
System.Drawing.Imaging.ImageLockMode.WriteOnly, screenShot.PixelFormat);
var sourcePtr = dx9Map.DataPointer;
var destPtr = bmpData.Scan0;
for (int y = 0; y < HEIGHT; y++)
{
// Copy a single line
Utilities.CopyMemory(destPtr, sourcePtr, ARGB_WIDTH);
// Advance pointers
sourcePtr = IntPtr.Add(sourcePtr, dx9Map.Pitch);
destPtr = IntPtr.Add(destPtr, bmpData.Stride);
}
screenShot.UnlockBits(bmpData);
dx9ScreenSurface.UnlockRectangle();
dx9ScreenSurface.Dispose();
bmpData = null;
GC.Collect();
return(screenShot);
}
catch (Exception ex)
{
LdpLog.Error("GetDX9ScreenShot error.\n" + ex.Message);
return(screenShot = null);
}
}
private void CheckPassword(string requestPassword)
{
if (requestPassword == settingsPassword)
{
infoRequest = new LdpClientInfoRequestHandler();
authResponse = packetFactory.SetAuthResponse(true);
responsePacket = packetFactory.BuildPacket(authResponse);
serverHandler.GetSenderChannel.Send(responsePacket);
LdpLog.Info("Auth successfull.");
serverHandler.GetListenerChannel.RemoveListener(this);
}
else
{
authResponse = packetFactory.SetAuthResponse(false);
responsePacket = packetFactory.BuildPacket(authResponse);
serverHandler.GetSenderChannel.Send(responsePacket);
LdpLog.Info("Auth failed: wrong password.");
serverHandler.GetListenerChannel.RemoveListener(this);
}
}
public void Send(LdpPacket packet)
{
try
{
using (var stream = new NetworkStream(serverHandler.GetSocketChannel))
{
packet.WriteDelimitedTo(stream);
}
}
catch (IOException ioexc)
{
LdpLog.Error("Send packet error:\n" + ioexc.Message);
}
catch (SocketException sockexc)
{
LdpLog.Error("Send packet error:\n" + sockexc.Message);
}
catch (Exception ex)
{
LdpLog.Error("Send packet error:\n" + ex.Message);
}
}
protected List <string> GetLocalIpAddressList()
{
var tmp = new List <string>();
try
{
IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
foreach (IPAddress ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
tmp.Add(ip.ToString());
}
}
return(tmp);
}
catch (SocketException sockexc)
{
LdpLog.Error("Getting IP address list error:\n" + sockexc.Message);
return(new List <string>());
}
}
private void InitializeServer(int port)
{
try
{
serverSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
IPEndPoint serverIPEP = new IPEndPoint(IPAddress.Any, port);
serverSocket.Bind(serverIPEP);
serverSocket.Listen(MAX_CONNECTIONS_PENDING);
PrintServerStarting();
//incoming connection
clientSocket = serverSocket.Accept();
clientEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint;
clientIP = clientEndPoint.Address.ToString();
LdpLog.Info(String.Format("Incoming connection: {0}.\nWaiting auth request..",
clientSocket.LocalEndPoint));
AddServerHandlers();
}
catch (SocketException sockexc)
{
switch (sockexc.ErrorCode)
{
//closing server
case SERVER_CLOSING_CODE:
LdpLog.Info("Closing server.");
StopServer();
break;
default:
LdpLog.Error("Starting server error:\n" + sockexc.Message);
StopServer();
break;
}
}
}
public void SendKey(string key, KeyboardKey type)
{
try
{
switch (type)
{
case KeyboardKey.KEY_TEXT:
Send(key);
break;
case KeyboardKey.KEY_ENTER:
SendKeys.SendWait(LdpKeys.ENTER);
break;
case KeyboardKey.KEY_DEL:
SendKeys.SendWait(LdpKeys.BACKSPACE);
break;
}
}
catch
{
LdpLog.Error("SendKeys unhandled key: " + key);
}
}
public void Restart()
{
LdpLog.Info("Restarting the server.");
base.StopServer();
base.StartServer(DEFAULT_PORT_NUMBER);
}
private Bitmap GetDX11ScreenShot()
{
try
{
screenShot = null;
screenShot = new Bitmap(WIDTH, HEIGHT, this.pixelFormat);
if (dx11DuplicatedOutput != null)
{
dx11DuplicatedOutput.AcquireNextFrame(NEXT_FRAME_TIMEOUT,
out dx11DuplFrameInfo, out dx11ScreenResource);
dx11Device.ImmediateContext
.CopyResource(dx11ScreenResource.QueryInterface <SharpDX.Direct3D11.Resource>(),
dx11ScreenTexture);
// cast from texture to surface, so we can access its bytes
dx11ScreenSurface = dx11ScreenTexture.QueryInterface <SharpDX.DXGI.Surface>();
// map the resource to access it
dx11Map = dx11ScreenSurface.Map(SharpDX.DXGI.MapFlags.Read);
bmpData = screenShot.LockBits(boundsRect, ImageLockMode.WriteOnly, screenShot.PixelFormat);
var sourcePtr = dx11Map.DataPointer;
var destPtr = bmpData.Scan0;
for (int y = 0; y < HEIGHT; y++)
{
// Copy a single line
Utilities.CopyMemory(destPtr, sourcePtr, ARGB_WIDTH);
// Advance pointers
sourcePtr = IntPtr.Add(sourcePtr, dx11Map.Pitch);
destPtr = IntPtr.Add(destPtr, bmpData.Stride);
}
dx11Device.ImmediateContext.UnmapSubresource(dx11ScreenTexture, 0);
screenShot.UnlockBits(bmpData);
dx11ScreenSurface.Unmap();
dx11ScreenSurface.Dispose();
dx11ScreenResource.Dispose();
dx11DuplicatedOutput.ReleaseFrame();
}
else
{
return(screenShot = null);
}
dx11ScreenSurface = null;
bmpData = null;
GC.Collect();
return(screenShot);
}
catch (SharpDX.SharpDXException e)
{
if (e.ResultCode.Code == SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code)
{
//screen does not changed
LdpLog.Warning("DX11 surface timeout.. Recursion is coming:)");
return(GetDX11ScreenShot());
}
else
{
return(screenShot = null);
}
}
catch (Exception ex)
{
LdpLog.Error("GetDX11ScreenShot\n" + ex.Message);
return(screenShot = null);
}
}
