private static void Sending_Completed(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
var arg = new System.Net.Sockets.SocketAsyncEventArgs() { };
arg.Completed += Receiving_Completed;
arg.SetBuffer(new byte[1000], 0, 1000);
_socket.ReceiveAsync(arg);
//throw new NotImplementedException();
}
public static void Execute(IPEndPoint IPEndPoint, byte[] command)
{
_socket = new System.Net.Sockets.Socket(
System.Net.Sockets.AddressFamily.InterNetwork,
System.Net.Sockets.SocketType.Stream,
System.Net.Sockets.ProtocolType.Tcp);
var arg = new System.Net.Sockets.SocketAsyncEventArgs() { RemoteEndPoint = IPEndPoint };
arg.SetBuffer(command, 0, command.Length);
arg.Completed += Sending_Completed;
var result = _socket.ConnectAsync(arg);
//socket.SendToAsync(arg);
}
public bool ConnectAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
throw null;
}
public bool AcceptAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
throw null;
}
public static void CancelConnectAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
}
/// <summary>
/// Initializes internal fields
/// </summary>
private void InitializeData()
{
// Initialize the Socket
_mainSocket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
DefaultEncoding = System.Text.Encoding.UTF8;
_receiveSocketArgs = new System.Net.Sockets.SocketAsyncEventArgs();
_sendSocketArgs = new System.Net.Sockets.SocketAsyncEventArgs();
}
protected virtual void OnCompleted(System.Net.Sockets.SocketAsyncEventArgs e)
{
}
public bool SendToAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
throw null;
}
/// <summary>
/// Send datas.
/// </summary>
/// <param name="data">Datas to send.</param>
public void Send(string data)
{
System.Net.Sockets.SocketAsyncEventArgs args = new System.Net.Sockets.SocketAsyncEventArgs();
if (p_twoSensesSocket.Connected)
{
receiveDone.Set();
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(data + String.Empty);
// p_socketSendEventArgs.SetBuffer(buffer, 0, buffer.Length);
args.Completed += new EventHandler<System.Net.Sockets.SocketAsyncEventArgs>(SocketSendEventArgs_Completed);
args.SetBuffer(buffer, 0, buffer.Length);
args.RemoteEndPoint = endPoint;
p_twoSensesSocket.ConnectAsync(args);
receiveDone.Reset();
}
}
// Removes the buffer from a SocketAsyncEventArg object.
// This frees the buffer back to the buffer pool
public void FreeBuffer(System.Net.Sockets.SocketAsyncEventArgs args)
{
freeIndexPool.Push(args.Offset);
args.SetBuffer(null, 0, 0);
}
public static bool ConnectAsync(System.Net.Sockets.SocketType socketType, System.Net.Sockets.ProtocolType protocolType, System.Net.Sockets.SocketAsyncEventArgs e)
{
return(default(bool));
}
public void Connect()
{
var connArgs = new System.Net.Sockets.SocketAsyncEventArgs();
Action <Object, System.Net.Sockets.SocketAsyncEventArgs> connCompleted =
(object _, System.Net.Sockets.SocketAsyncEventArgs __) =>
{
if (connArgs.SocketError != System.Net.Sockets.SocketError.Success)
{
Console.WriteLine("Error Connecting");
throw new Exception(connArgs.SocketError.ToString());
}
byte[] buffer = new byte[4096 * 4096];
StringBuilder sb = new StringBuilder("");
var nested = 0;
Action <Object, System.Net.Sockets.SocketAsyncEventArgs> action = null;
Action <Object, System.Net.Sockets.SocketAsyncEventArgs> rcvCompleted =
(object ___, System.Net.Sockets.SocketAsyncEventArgs args) =>
{
if (args.BytesTransferred <= 0)
{
return;
}
if (args.SocketError != System.Net.Sockets.SocketError.Success)
{
Console.WriteLine("Error Receiving");
throw new Exception(args.SocketError.ToString());
}
string content = Encoding.UTF8.GetString(buffer, 0, args.BytesTransferred);
foreach (char c in content)
{
sb.Append(c);
if (c == '{')
{
nested++;
}
if (c == '}')
{
nested--;
}
if (nested < 0)
{
Console.WriteLine("negative nesting!");
throw new Exception("negative nesting");
}
if (nested == 0)
{
string str = sb.ToString();
sb.Clear();
// Console.WriteLine("unwrapped nesting!");
// Console.WriteLine(str);
var obj = JObject.Parse(str);
Call(obj["evt"].ToString(), obj["data"] as JObject);
}
}
args.SetBuffer(buffer, 0, buffer.Length);
if (!socket.ReceiveAsync(args))
{
action.Invoke(null, args);
}
};
action = rcvCompleted;
var rcvArgs = new System.Net.Sockets.SocketAsyncEventArgs();
rcvArgs.SetBuffer(buffer, 0, buffer.Length);
rcvArgs.Completed += new EventHandler <System.Net.Sockets.SocketAsyncEventArgs>(
rcvCompleted
);
if (!socket.ReceiveAsync(rcvArgs))
{
rcvCompleted(null, rcvArgs);
}
Call("connect", null);
};
connArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(host), port);
connArgs.Completed += new EventHandler <System.Net.Sockets.SocketAsyncEventArgs>(
connCompleted
);
if (!socket.ConnectAsync(connArgs))
{
connCompleted(null, connArgs);
}
}
public bool OnReceiveAsync(System.Net.Sockets.SocketAsyncEventArgs arg)
{
pmIn.New();
Console.WriteLine("OnReceiveAsync -> {0} bytes", arg.BytesTransferred);
switch (pmIn.Read())
{
case Command.NETWORK_STREAM:
break;
case Command.NETWORK_STREAM_ADD_COMMAND:
break;
case Command.NETWORK_STREAM_CONNECT:
break;
case Command.NETWORK_STREAM_CONNECT_SUCCESS:
break;
case Command.NETWORK_STREAM_LAST:
break;
case Command.NETWORK_STREAM_NULL:
break;
case Command.NETWORK_STREAM_READY:
break;
case Command.NETWORK_STREAM_SEND:
break;
case Command.NETWORK_STREAM_SEND_CORRUPTED:
break;
case Command.NETWORK_STREAM_SEND_INIT:
Console.WriteLine("NETWORK_STREAM_SEND_INIT");
Command c = pmIn.Read();
Console.WriteLine(c);
if (c == Command.NETWORK_STREAM_SEND_SIMPLE)
{
ReceiveSimple();
}
else
{
Receive();
}
break;
case Command.NETWORK_STREAM_SEND_LAST:
break;
case Command.NETWORK_STREAM_SEND_SUCCESS:
break;
case Command.NETWORK_STREAM_SEND_WAS_LAST:
break;
default:
pmIn.New();
Console.WriteLine(pmIn.Read());
break;
}
return(true);
}
public uint Receive(Byte[] buff, int len, SocketFlags flags)
{
if (mForceReconnect)
{
mReadDone.Reset();
return(SOCKET_ERROR);
}
uint AmountRead = 0;
if (mSocket != null)
{
if (mAvailable != 0)
{
AmountRead = (mAvailable <= len) ? mAvailable : (uint)len;
if (mOffset + AmountRead > MAX_BUFFER_SIZE)
{
throw new SocketException();
}
for (int i = 0; i < AmountRead; ++i)
{
buff[i] = mReadBuffer[mOffset + i];
}
mAvailable -= AmountRead;
mOffset += AmountRead;
if (mAvailable == 0)
{
Array.Clear(mReadBuffer, 0, MAX_BUFFER_SIZE);
mOffset = 0;
}
}
else
{
mReadDone.WaitOne();
mReadDone.Reset();
}
if (mReadAmount != 0)
{
if (mReadAmount <= (uint)len)
{
AmountRead = mReadAmount;
mAvailable = 0;
mOffset = 0;
}
else
{
AmountRead = (uint)len;
mAvailable = mReadAmount - (uint)len;
mOffset = (uint)len;
}
if (AmountRead > MAX_BUFFER_SIZE)
{
throw new SocketException();
}
for (int i = 0; i < AmountRead; ++i)
{
buff[i] = mReadBuffer[i];
}
if (mAvailable == 0)
{
Array.Clear(mReadBuffer, 0, MAX_BUFFER_SIZE);
}
mReadAmount = 0;
}
if (mAvailable == 0)
{
System.Net.Sockets.SocketAsyncEventArgs socketEventArg = new System.Net.Sockets.SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = mSocket.RemoteEndPoint;
socketEventArg.UserToken = this;
// Setup the buffer to receive the data
socketEventArg.SetBuffer(mReadBuffer, 0, MAX_BUFFER_SIZE);
socketEventArg.Completed += new EventHandler <System.Net.Sockets.SocketAsyncEventArgs>(
delegate(object s, System.Net.Sockets.SocketAsyncEventArgs e)
{
Socket userToken = e.UserToken as Socket;
if (null != userToken)
{
if (e.SocketError == System.Net.Sockets.SocketError.Success)
{
userToken.mReadAmount = (uint)e.BytesTransferred;
userToken.mReadDone.Set();
}
else
{
mForceReconnect = true;
userToken.mReadDone.Set();
}
if (!userToken.Connected)
{
mForceReconnect = true;
userToken.mReadDone.Set();
}
}
});
mSocket.ReceiveAsync(socketEventArg);
}
}
if (!Connected)
{
return(SOCKET_ERROR);
}
return(AmountRead);
}
protected override void OnCompleted(System.Net.Sockets.SocketAsyncEventArgs _)
{
}
public bool OnReceiveAsyncInput(System.Net.Sockets.SocketAsyncEventArgs arg)
{
return(false);
}
public static bool ConnectAsync(System.Net.Sockets.SocketType socketType, System.Net.Sockets.ProtocolType protocolType, System.Net.Sockets.SocketAsyncEventArgs e)
{
throw null;
}
public bool ReceiveFromAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
return(default(bool));
}
public bool ReceiveMessageFromAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
throw null;
}
public UserInfo(System.Net.Sockets.SocketAsyncEventArgs asyn)
{
this.Asyn = asyn;
this.Stream = new ZYNetBufferReadStreamV2(1024 * 1024 * 4);
}
private static void Receiving_Completed(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
_socket.Dispose();
_socket = null;
}
public bool DisconnectAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
return(default(bool));
}
public bool SendAsync(System.Net.Sockets.SocketAsyncEventArgs e)
{
return(default(bool));
}
private bool OnReceiveAsync(System.Net.Sockets.SocketAsyncEventArgs arg)
{
// Get the client object from arg
SOCKET.Client client = (SOCKET.Client)arg.UserToken;
// Notes: First 4 bytes are the size of the message.
// Notes: It's impossible to send only 4 bytes, as that would mean we only send the message size, which doesn't make sense , so this must be always bigger than 4 bytes
if (arg.BytesTransferred > 4 && client.pmIn.NewRead() == arg.BytesTransferred)
{
lastCommand = client.pmIn.ReadCommand();
switch (lastCommand)
{
// Connection attempt
case Command.CONNECT:
#region CONNECT
{
cw.WriteLine(Remote.Language.Find("IncomingConnection", this, "Incoming connection attempt from: {0}"), client.ClientAddress);
Command c = client.pmIn.ReadCommand();
if (c == Command.USER_NAME)
{
Dispatcher.Invoke(new Action(() =>
{
foreach (var cd in clients)
{
if (cd.client == client)
{
cd.name = client.pmIn.ReadString();
cd.lName.Content = cd.name;
connectedComputersItems.Add(cd.sp);
ConnectedComputers.ItemsSource = connectedComputersItems;
break;
}
}
}),
DispatcherPriority.Render);
client.pmOut.New();
client.pmOut.Write(Command.CONNECT_SUCCESS);
client.pmOut.Write(Command.USER_NAME);
client.pmOut.Write(Settings.s.name);
client.pmOut.End();
if (client.SendSafe())
{
cw.WriteLine(Remote.Language.Find("ClientConnectSuccess", this, "Client from {0} successfully connected!"), client.ClientAddress);
return(true);
}
else
{
cw.WriteLine(client.lastSendException.Message);
client.Close();
client = null;
}
}
}
break;
#endregion
// Success!
case Command.CONNECT_SUCCESS:
#region CONNECT_SUCCES
{
cw.WriteLine(Remote.Language.Find("ClientConnected", this, "Succesfully connected to {0}"), client.ClientAddress);
Command c = client.pmIn.ReadCommand();
if (c == Command.USER_NAME)
{
Dispatcher.Invoke(new Action(() =>
{
ClientData cd = new ClientData();
cd.client = client;
Label l = new Label();
cd.name = client.pmIn.ReadString();
cd.lName = l;
l.Content = cd.name;
StackPanel sp = new StackPanel();
sp.Children.Add(l);
//connectedComputersBinding.Add(sp, cd);
clients[sp] = cd;
connectedComputersItems.Add(sp);
ConnectedComputers.ItemsSource = connectedComputersItems;
}),
DispatcherPriority.Render);
}
return(true);
}
#endregion
case Command.REMOTE_DESKTOP_REQUEST:
#region REMOTE_DESKTOP_REQUEST
{
ClientData cd = clients[(SOCKET.Client)arg.UserToken];
cd.remoteDesktopRequest = true;
Dispatcher.Invoke(new Action(() =>
{
ConnectedComputers_SelectionChanged(null, null);
}), DispatcherPriority.Render);
cw.WriteLine(Remote.Language.Find("RemoteDesktopRequestIncoming", this, "A Remote Desktop request was received from {0} / {1}"), cd.name, cd.client.ClientAddress);
return(true);
}
#endregion
case Command.REMOTE_DESKTOP_CAPTURE_INFO_REQUEST:
#region REMOTE_DESKTOP_CAPTURE_INFO_REQUEST
{
Dispatcher.Invoke(new Action(() =>
{
this.WindowState = System.Windows.WindowState.Minimized;
loader.Show();
}), DispatcherPriority.Render);
loader.ChangeText("Sending streaming settings...");
ClientData cd = clients[(SOCKET.Client)arg.UserToken];
cd.client.pmOut.New();
cd.client.pmOut.Write(Command.REMOTE_DESKTOP_CAPTURE_INFO);
ProtoBuf.Serializer.SerializeWithLengthPrefix(cd.client.pmOut.Stream, Settings.s.remoteDesktopSettings, ProtoBuf.PrefixStyle.Base128);
cd.client.pmOut.End();
if (cd.client.SendSafe())
{
return(true);
}
else
{
}
}
break;
#endregion
case Command.REMOTE_DESKTOP_CAPTURE_INFO:
#region REMOTE_DESKTOP_CAPTURE_INFO
{
loader.ChangeText("Creating host...");
ClientData cd = clients[(SOCKET.Client)arg.UserToken];
Settings.RemoteDesktopSettings s = ProtoBuf.Serializer.DeserializeWithLengthPrefix <Settings.RemoteDesktopSettings>(cd.client.pmIn.Stream, ProtoBuf.PrefixStyle.Base128);
host = new RemoteDesktopHost(s);
cd.client.pmOut.New();
cd.client.pmOut.Write(Command.REMOTE_DESKTOP_HOST_READY);
cd.client.pmOut.Write(SystemParameters.PrimaryScreenWidth);
cd.client.pmOut.Write(SystemParameters.PrimaryScreenHeight);
cd.client.pmOut.End();
if (cd.client.SendSafe())
{
return(true);
}
else
{
}
}
break;
#endregion
case Command.REMOTE_DESKTOP_HOST_READY:
#region REMOTE_DESKTOP_HOST_READY
{
loader.ChangeText("Creating streaming connection...");
bool whatToReturn = false;
RemoteDesktop rd;
Dispatcher.Invoke(new Action(() =>
{
rd = new RemoteDesktop();
rd.x = (int)client.pmIn.ReadDouble();
rd.y = (int)client.pmIn.ReadDouble();
System.Net.IPAddress address = client.ClientAddress;
rd.clientStream = new SOCKET.Client();
rd.clientStream.socket = new System.Net.Sockets.Socket(new System.Net.IPEndPoint(address, Settings.s.remoteDesktopPort).AddressFamily, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
try
{
rd.clientStream.socket.Connect(address, Settings.s.remoteDesktopPort);
rd.clientStream.StartReceiveAsync(rd.OnReceiveAsyncStream);
rd.clientStream.socket.SendTimeout = 5000;
rd.clientStream.socket.ReceiveTimeout = 5000;
rd.clientStream.pmOut.Write(Command.REMOTE_DESKTOP_CONNECT_STREAM);
rd.clientStream.pmOut.End();
if (rd.clientStream.SendSafe())
{
//cw.WriteLine(Remote.Language.Find("ClientConnecting", this, "Connecting to {0}"), Address.Text);
whatToReturn = true;
}
else
{
cw.WriteLine(rd.clientStream.lastSendException.Message);
rd.clientStream.Close();
rd.clientStream = null;
whatToReturn = false;
}
//cw.WriteLine(Remote.Language.Find("ClientConnected", this, "Succesfully conencted to {0}"), Address.Text);
}
catch (System.Net.Sockets.SocketException ee)
{
cw.WriteLine(ee.Message);
rd.clientStream.Close();
rd.clientStream = null;
}
}), DispatcherPriority.Render);
if (whatToReturn)
{
return(true);
}
else
{
return(false);
}
}
#endregion
case Command.REMOTE_DESKTOP_CONNECT_STREAM:
#region REMOTE_DESKTOP_CONNECT_STREAM
{
loader.ChangeText("Streaming connection created...");
ClientData cd = clients[(SOCKET.Client)arg.UserToken];
Dispatcher.Invoke(new Action(() =>
{
cd.sp.Children.Remove(cd.lName);
clients.Remove(cd);
host.clientStream = cd.client;
host.clientStream.onReceiveAsync = host.OnReceiveAsync;
}), DispatcherPriority.Render);
host.clientStream.pmOut.New();
host.clientStream.pmOut.Write(Command.REMOTE_DESKTOP_CONNECT_STREAM_SUCCESS);
host.clientStream.pmOut.End();
if (host.clientStream.SendSafe())
{
return(true);
}
else
{
}
// send success
}
break;
#endregion
case Command.REMOTE_DESKTOP_CONNECT_INPUT:
#region REMOTE_DESKTOP_CONNECT_INPUT
{
loader.ChangeText("Input stream created...");
ClientData cd = clients[(SOCKET.Client)arg.UserToken];
Dispatcher.Invoke(new Action(() =>
{
cd.sp.Children.Remove(cd.lName);
clients.Remove(cd);
host.clientInput = cd.client;
host.clientInput.onReceiveAsync = host.OnReceiveAsyncInput;
}), DispatcherPriority.Render);
host.clientInput.pmOut.New();
host.clientInput.pmOut.Write(Command.REMOTE_DESKTOP_CONNECT_INPUT_SUCCESS);
host.clientInput.pmOut.End();
if (host.clientInput.SendSafe())
{
return(true);
}
else
{
}
// send success
}
break;
#endregion
default:
break;
}
}
//Client disconnected, clean up.
else if (arg.BytesTransferred == 0)
{
switch (lastCommand)
{
// Error? EMPTY_COMMAND = 0
case Command.EMPTY_COMMAND:
break;
// Restore MainWindow upon client fail
case Command.REMOTE_DESKTOP_CAPTURE_INFO_REQUEST:
{
Dispatcher.Invoke(new Action(() =>
{
loader.Close();
loader = new RemoteGuiLoader.MainWindow();
WindowState = System.Windows.WindowState.Normal;
}), DispatcherPriority.Render);
cw.WriteLine(Remote.Language.Find("RemoteDekstopCaptureInfoRequestClientDisconnected", this, "The client disconnected during Remote Desktop initialization"));
}
break;
default:
break;
}
foreach (var item in connectedComputersItems)
{
}
//cw.WriteLine("End");
}
return(false);
}