protected internal RuntimeValue_Primitive( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
Type t;
switch((RuntimeDataType)handle.m_dt)
{
case RuntimeDataType.DATATYPE_BOOLEAN: t = typeof( bool ); break;
case RuntimeDataType.DATATYPE_I1 : t = typeof(sbyte ); break;
case RuntimeDataType.DATATYPE_U1 : t = typeof( byte ); break;
case RuntimeDataType.DATATYPE_CHAR : t = typeof( char ); break;
case RuntimeDataType.DATATYPE_I2 : t = typeof( short ); break;
case RuntimeDataType.DATATYPE_U2 : t = typeof(ushort ); break;
case RuntimeDataType.DATATYPE_I4 : t = typeof( int ); break;
case RuntimeDataType.DATATYPE_U4 : t = typeof(uint ); break;
case RuntimeDataType.DATATYPE_R4 : t = typeof( float ); break;
case RuntimeDataType.DATATYPE_I8 : t = typeof( long ); break;
case RuntimeDataType.DATATYPE_U8 : t = typeof(ulong ); break;
case RuntimeDataType.DATATYPE_R8 : t = typeof( double); break;
default: throw new ArgumentException( String.Format( "Not a primitive: {0}", handle.m_dt ) );
}
m_value = System.Runtime.Serialization.FormatterServices.GetUninitializedObject( t );
m_eng.CreateConverter().Deserialize( m_value, handle.m_builtinValue );
}
protected internal RuntimeValue_Indirect( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array[pos] )
{
if(++pos < array.Length)
{
m_value = Convert( eng, array, pos );
}
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
protected override void SendMessageInternal(IScsMessage message)
{
//Send message
var totalSent = 0;
lock (_syncLock)
{
//Create a byte array from message according to current protocol
var messageBytes = WireProtocol.GetBytes(message);
//Send all bytes to the remote application
while (totalSent < messageBytes.Length)
{
var sent = _clientSocket.Send(messageBytes, totalSent, messageBytes.Length - totalSent, SocketFlags.None);
if (sent <= 0)
{
throw new CommunicationException("Message could not be sent via TCP socket. Only " + totalSent + " bytes of " + messageBytes.Length + " bytes are sent.");
}
totalSent += sent;
}
LastSentMessageTime = DateTime.Now;
OnMessageSent(message);
}
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
protected override void SendMessageInternal(IScsMessage message)
{
//Send message
var totalSent = 0;
lock (_syncLock)
{
//Create a byte array from message according to current protocol
var messageBytes = WireProtocol.GetBytes(message);
//Send all bytes to the remote application
try
{
_sslStream.Write(messageBytes, totalSent, messageBytes.Length);
}
catch
{
throw new CommunicationException("Cannot send data on the SSL stream");
}
LastSentMessageTime = DateTime.Now;
OnMessageSent(message);
}
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method. It
/// reveives bytes from socker.
/// </summary>
/// <param name="result">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult result)
{
if (!_running)
{
return;
}
try
{
int bytesRead = -1;
// Get received bytes count
bytesRead = _clientSocket.EndReceive(result);
if (bytesRead > 0)
{
switch (BitConverter.ToUInt16(_buffer, 0))
{
case PING_REQUEST:
_clientSocket.Send(BitConverter.GetBytes(PING_RESPONSE));
goto CONT_RECEIVE;
case PING_RESPONSE:
_running = false;
return;
}
LastReceivedMessageTime = DateTime.Now;
// Copy received bytes to a new byte array
byte[] receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, receivedBytes, bytesRead);
// Read messages according to current wire protocol and raise MessageReceived
// event for all received messages
foreach (IScsMessage message in WireProtocol.CreateMessages(receivedBytes))
{
OnMessageReceived(message, DateTime.Now);
}
}
else
{
Logger.Warn(Language.Instance.GetMessageFromKey("CLIENT_DISCONNECTED"));
Disconnect();
}
CONT_RECEIVE:
// Read more bytes if still running
if (_running)
{
_clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, ReceiveCallback, null);
}
}
catch (Exception)
{
Disconnect();
}
}
public Task HandleStream(IReceiverCallback callback, Stream stream)
{
if (Status == ListeningStatus.TooBusy)
{
return(stream.SendBuffer(WireProtocol.ProcessingFailureBuffer));
}
return(WireProtocol.Receive(stream, callback, Address));
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
/// <param name="priority">Priority of message to send</param>
protected override void SendMessagepublic(IScsMessage message, byte priority)
{
if (priority > 5)
{
_highPriorityBuffer.Enqueue(WireProtocol.GetBytes(message));
}
else
{
_lowPriorityBuffer.Enqueue(WireProtocol.GetBytes(message));
}
}
protected internal RuntimeValue_ByRef( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array, pos )
{
if(m_value == null && m_handle.m_arrayref_referenceID != 0)
{
m_value = m_eng.GetArrayElement( m_handle.m_arrayref_referenceID, m_handle.m_arrayref_index );
}
if(m_value == null)
{
throw new ArgumentException();
}
}
/// <summary>
/// Connects to server.
/// </summary>
public void Connect()
{
WireProtocol.Reset();
_communicationChannel = CreateCommunicationChannel();
_communicationChannel.WireProtocol = WireProtocol;
_communicationChannel.Disconnected += CommunicationChannel_Disconnected;
_communicationChannel.MessageReceived += CommunicationChannel_MessageReceived;
_communicationChannel.MessageSent += CommunicationChannel_MessageSent;
_communicationChannel.Start();
//_pingTimer.Start();
OnConnected();
}
/// <summary>
/// Connects to server.
/// </summary>
public void Connect(params Tuple <SocketOptionLevel, SocketOptionName, object>[] socketOptions)
{
WireProtocol.Reset();
_communicationChannel = CreateCommunicationChannel(socketOptions);
_communicationChannel.WireProtocol = WireProtocol;
_communicationChannel.Disconnected += CommunicationChannel_Disconnected;
_communicationChannel.MessageReceived += CommunicationChannel_MessageReceived;
_communicationChannel.MessageSent += CommunicationChannel_MessageSent;
_communicationChannel.Start();
_pingTimer.Start();
OnConnected();
}
public static void updateWindowCap(int hWnd, Bitmap cap)
{
try
{
_processDict[hWnd].WindowCap = cap;
CompRequest updateCapRequest = WireProtocol.createProgramMessage(Guid.NewGuid().ToString(), hWnd, (byte[])converter.ConvertTo(cap, typeof(byte[])));
//cListener.phoneCommChannel.sendMessage(WireProtocol.serializeMessage(updateCapRequest));
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e.ToString());
}
}
static void MouseAndPingerLoop(UsbStream mouse, UsbStream pinger)
{
// Allocate in and out packets for "TinyBooter" simulation
WireProtocol.WP_Packet inPacket; // Allocate packet for Pinger input
UInt16 seq = 0; // Initialize Pinger packet sequence number
// While done button is not pressed
while (buttons.done.Read())
{
// Perform these operations once every 10 milliseconds (actually a bit more than 10 milliseconds)
// We've asked the host to query for mouse info at least every 10 milliseconds, but it actually
// queries every 8 milliseconds - it's OK not to respond to every query.
Thread.Sleep(10);
byte xChange = 0;
byte yChange = 0;
// Make the mouse move by 3 steps each sample time if any movement button is pressed
if (!buttons.up.Read())
{
yChange = 0xFD;
}
if (!buttons.down.Read())
{
yChange = 3;
}
if (!buttons.left.Read())
{
xChange = 0xFD;
}
if (!buttons.right.Read())
{
xChange = 3;
}
// Report to host the condition of "movement" or of the buttons
SendMouseReport(mouse, !buttons.b1.Read(), !buttons.b2.Read(), !buttons.b3.Read(), xChange, yChange);
// If a good WireProtocol packet was received from the host
if (WireProtocol.ReadPacket(pinger, out inPacket))
{
RespondToPacket(pinger, inPacket, seq);
}
}
// Wait for the done button to be released
while (!buttons.done.Read())
{
;
}
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method.
/// It reveives bytes from socker.
/// </summary>
/// <param name="ar">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult ar)
{
if (!_running)
{
return;
}
try
{
//Get received bytes count
var bytesRead = _clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
LastReceivedMessageTime = DateTime.Now;
//Copy received bytes to a new byte array
var receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, 0, receivedBytes, 0, bytesRead);
try
{
//Read messages according to current wire protocol
var messages = WireProtocol.CreateMessages(receivedBytes);
//Raise MessageReceived event for all received messages
foreach (var message in messages)
{
OnMessageReceived(message);
}
}
catch (SerializationException ex)
{
System.Diagnostics.Trace.Write($"Error while deserializing message: {ex}");
}
}
else
{
throw new CommunicationException("Tcp socket is closed");
}
//Read more bytes if still running
if (_running)
{
_clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
}
}
catch (Exception exception)
{
System.Diagnostics.Trace.Write($"ReceiveCallback: {exception}");
Disconnect();
}
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method.
/// It reveives bytes from socker.
/// </summary>
/// <param name="ar">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult ar)
{
if (!_running)
{
return;
}
// stop timer to receives bytes from socket
_timerConnect.Stop();
try
{
//Get received bytes count
var bytesRead = _clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
LastReceivedMessageTime = DateTime.Now;
//Copy received bytes to a new byte array
var receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, 0, receivedBytes, 0, bytesRead);
//Read messages according to current wire protocol
var messages = WireProtocol.CreateMessages(receivedBytes);
//Raise MessageReceived event for all received messages
foreach (var message in messages)
{
OnMessageReceived(message);
}
}
else
{
throw new CommunicationException("Tcp socket is closed");
}
//Read more bytes if still running
if (_running)
{
_clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
}
}
catch
{
Disconnect();
}
// Start timer again
_timerConnect.Start();
}
public static void addProgram(int key, ProgramBase pInt)
{
_processDict.Add(key, pInt);
currentProcess = pInt;
try
{
CompRequest message = WireProtocol.createProgramMessage(Guid.NewGuid().ToString(), key, pInt.WindowTitle, (byte[])converter.ConvertTo(pInt.WindowCap, typeof(byte[])), pInt.ProgramType);
//cListener.phoneCommChannel.startThread(WireProtocol.serializeMessage(message));
}
catch (NullReferenceException e) {
Console.WriteLine(e.ToString());
}
//send phone update on process
}
protected internal RuntimeValue_String( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
byte[] buf = handle.m_builtinValue;
if(handle.m_bytesInString >= buf.Length)
{
if(m_eng.ReadMemory( m_handle.m_charsInString, m_handle.m_bytesInString, out buf ) == false)
{
// Revert to the preview on failure
buf = handle.m_builtinValue;
}
}
m_value = WireProtocol.Commands.GetZeroTerminatedString( buf, true );
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method. It
/// reveives bytes from socker.
/// </summary>
/// <param name="ar">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult ar)
{
if (!_running)
{
return;
}
try
{
var bytesRead = -1;
// Get received bytes count
bytesRead = _clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
LastReceivedMessageTime = DateTime.Now;
// Copy received bytes to a new byte array
var receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, receivedBytes, bytesRead);
// Read messages according to current wire protocol
var messages = WireProtocol.CreateMessages(receivedBytes);
// Raise MessageReceived event for all received messages
foreach (var message in messages)
{
OnMessageReceived(message, DateTime.Now);
}
}
else
{
Logger.Log.Warn(Language.Instance.GetMessageFromKey("CLIENT_DISCONNECTED"));
Disconnect();
}
// Read more bytes if still running
if (_running)
{
_clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
}
}
catch
{
Disconnect();
}
}
public PcapParser(string pcappath, string serverIp, string clientIp)
{
_serverIp = serverIp;
_clientIp = clientIp;
_capturedPackets = new List<PacketWrapper>();
_serverWireProtocol = new WireProtocol<ConanPacket>();
_clientWireProtocol = new WireProtocol<ConanPacket>();
_device = new CaptureFileReaderDevice(pcappath)
{
//Filter = "(ip and tcp) and (host " + serverIp + " or host " + clientIp + ")"
Filter = "(ip and tcp) and host " + serverIp
};
_device.OnPacketArrival += OnPacketArrival;
}
public PcapParser(string pcappath, string serverIp, string clientIp)
{
_serverIp = serverIp;
_clientIp = clientIp;
_capturedPackets = new List <PacketWrapper>();
_serverWireProtocol = new WireProtocol <ConanPacket>();
_clientWireProtocol = new WireProtocol <ConanPacket>();
_device = new CaptureFileReaderDevice(pcappath)
{
//Filter = "(ip and tcp) and (host " + serverIp + " or host " + clientIp + ")"
Filter = "(ip and tcp) and host " + serverIp
};
_device.OnPacketArrival += OnPacketArrival;
}
protected async Task afterSending()
{
_listener.Start();
using (var client = new TcpClient())
{
if (Dns.GetHostName() == destination.Host)
{
await client.ConnectAsync(IPAddress.Loopback, destination.Port);
}
await client.ConnectAsync(destination.Host, destination.Port);
await WireProtocol.Send(client.GetStream(), theMessageBatch, null, theSender);
}
}
Event DecodeEventInfo (WireProtocol.EventInfo info) {
EventRequest req = FindRequest (info.requestId);
if (info.eventKind == WireProtocol.EVENT_VM_START) {
WireProtocol.VMStartEventInfo einfo = (WireProtocol.VMStartEventInfo)info;
return new VMStartEventImpl (vm, req, new ThreadReferenceImpl (vm, einfo.thread), new AppDomainMirrorImpl (vm, einfo.domain));
} else if (info.eventKind == WireProtocol.EVENT_VM_DEATH) {
return new VMDeathEventImpl (vm, req);
} else if (info.eventKind == WireProtocol.EVENT_THREAD_START) {
WireProtocol.ThreadStartEventInfo einfo = (WireProtocol.ThreadStartEventInfo)info;
return new ThreadStartEventImpl (vm, req, new ThreadReferenceImpl (vm, einfo.thread));
} else if (info.eventKind == WireProtocol.EVENT_THREAD_DEATH) {
WireProtocol.ThreadDeathEventInfo einfo = (WireProtocol.ThreadDeathEventInfo)info;
return new ThreadDeathEventImpl (vm, req, new ThreadReferenceImpl (vm, einfo.thread));
} else {
throw new NotImplementedException ();
}
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
protected override void SendMessagepublic(IScsMessage message)
{
try
{
if (_clientSocket.Connected)
{
// Create a byte array from message according to current protocol
var messageBytes = WireProtocol.GetBytes(message);
// Begin sending the data to the remote device
_clientSocket.BeginSend(messageBytes, 0, messageBytes.Length, SocketFlags.None,
new AsyncCallback(SendCallback), _clientSocket);
}
}
catch (Exception e)
{
// disconnect
}
}
void receiver_thread_main()
{
Connection conn = vm.Connection;
while (true)
{
byte[] packet = conn.ReadPacket();
if (packet.Length == 0)
{
disconnected = true;
VMDisconnectEventImpl ev = new VMDisconnectEventImpl(vm, null);
add_event_set(new EventSetImpl(vm, new Event [] { ev }, SuspendPolicy.SuspendNone));
break;
}
if (WireProtocol.IsReplyPacket(packet))
{
/* Reply packet */
int id = WireProtocol.GetPacketId(packet);
lock (reply_packets_monitor)
{
reply_packets [id] = packet;
Monitor.PulseAll(reply_packets_monitor);
}
}
else
{
WireProtocol.Packet decoded = WireProtocol.DecodePacket(packet);
if (decoded is WireProtocol.Event.CompositePacket)
{
WireProtocol.Event.CompositePacket p = (WireProtocol.Event.CompositePacket)decoded;
Event[] events = new Event [p.events.Length];
for (int i = 0; i < p.events.Length; ++i)
{
events [i] = DecodeEventInfo(p.events [i]);
}
add_event_set(new EventSetImpl(vm, events, p.suspendPolicy));
}
}
}
}
public ListeningAgent(IReceiverCallback callback, IPAddress ipaddr, int port, string protocol, CancellationToken cancellationToken)
{
Port = port;
_callback = callback;
_cancellationToken = cancellationToken;
_listener = new TcpListener(new IPEndPoint(ipaddr, port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(async s =>
{
using (var stream = new NetworkStream(s, true))
{
await WireProtocol.Receive(stream, _callback, _uri);
}
});
_uri = $"{protocol}://{ipaddr}:{port}/".ToUri();
}
// Accepts only a good packet. If the packet is a Ping, the Ping response (ACK) is sent.
// Otherwise, the command is NAK'ed.
static bool RespondToPacket(UsbStream pinger, WireProtocol.WP_Packet inPacket, UInt16 seq)
{
WireProtocol.WP_Packet outPacket = new WireProtocol.WP_Packet();
// Allocate space for any data following the packet
int size = (int)(inPacket.m_size & 0xFFFF);
byte[] buffer = new byte[size];
// Read in the data that came with the packet
if (inPacket.m_size != 0)
{
pinger.Read(buffer, 0, size);
}
// Fill in the blanks of the response packet
outPacket.m_signature = "MSdbgV1"; // Standard target signature
outPacket.m_cmd = inPacket.m_cmd; // Show which command this is a response to
outPacket.m_seq = seq++; // Keep track of the target message sequence number
outPacket.m_seqReply = inPacket.m_seq; // Show which host packet sequence number this is a response to
// If the host packet was a Ping
if (inPacket.m_cmd == WireProtocol.Commands.Ping)
{
byte[] data = new byte[8]; // The Ping has an 8 byte data response
outPacket.m_flags = 0x8003; // Return a low-priority ACK
for (int i = 0; i < 8; i++)
{
data[i] = 0; // Initialize all bytes of the data response to zero
}
data[0] = 1; // This tells the host that we are TinyBooter
data[4] = 2; // This is an innoccuous flag value
WireProtocol.SendPacket(pinger, outPacket, data); // Send response to the Ping
}
else
{
outPacket.m_flags = 0x4003; // Return a low-priority NACK
WireProtocol.SendPacket(pinger, outPacket, new byte[0]); // Signal to the host that we don't know what to do with the command
}
return(true);
}
public async Task SendBatch(ISenderCallback callback, OutgoingMessageBatch batch)
{
if (batch.Data.Length == 0)
{
throw new Exception("No data to be sent");
}
using (var client = new TcpClient())
{
var connection = connect(client, batch.Destination)
.TimeoutAfter(5000);
await connection;
if (connection.IsCompleted)
{
using (var stream = client.GetStream())
{
var protocolTimeout = WireProtocol.Send(stream, batch, batch.Data, callback);
//var protocolTimeout = .TimeoutAfter(5000);
await protocolTimeout.ConfigureAwait(false);
if (!protocolTimeout.IsCompleted)
{
await callback.TimedOut(batch);
}
if (protocolTimeout.IsFaulted)
{
await callback.ProcessingFailure(batch, protocolTimeout.Exception);
}
}
}
else
{
await callback.TimedOut(batch);
}
}
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
protected override void SendMessageInternal(IScsMessage message)
{
//Send message
var totalSent = 0;
lock (_syncLock)
{
//Create a byte array from message according to current protocol
var messageBytes = WireProtocol.GetBytes(message);
//Send all bytes to the remote application
while (totalSent < messageBytes.Length)
{
try
{
var sent = _clientSocket.Send(messageBytes, totalSent, messageBytes.Length - totalSent, SocketFlags.None);
if (sent <= 0)
{
throw new CommunicationException("Message could not be sent via TCP socket. Only " + totalSent + " bytes of " + messageBytes.Length + " bytes are sent.");
}
totalSent += sent;
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.WouldBlock ||
ex.SocketErrorCode == SocketError.IOPending ||
ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
{
// socket buffer is probably full, wait and try again
Thread.Sleep(30);
}
}
}
LastSentMessageTime = DateTime.Now;
OnMessageSent(message);
}
}
/// <summary>
/// Sends a message to the remote application.
/// </summary>
/// <param name="message">Message to be sent</param>
protected override void SendMessagepublic(IScsMessage message)
{
//Send message
var totalSent = 0;
lock (_syncLock)
{
//Create a byte array from message according to current protocol
var messageBytes = WireProtocol.GetBytes(message);
//Send all bytes to the remote application
while (totalSent < messageBytes.Length)
{
if (_clientSocket.Connected)
{
var sent = 0;
try
{
sent = _clientSocket.Send(messageBytes, totalSent, messageBytes.Length - totalSent, SocketFlags.None);
}
catch (Exception e)
{
//annoying bug
Logger.Log.Error("A packet would have been sent to a disconnected client. IGNORE THIS.", e);
}
if (sent <= 0)
{
throw new CommunicationException("Message could not be sent via TCP socket. Only " + totalSent + " bytes of " + messageBytes.Length + " bytes are sent.");
}
totalSent += sent;
}
}
LastSentMessageTime = DateTime.Now;
OnMessageSent(message);
}
}
static void PingerLoop(UsbStream pinger)
{
// Allocate in and out packets for "TinyBooter" simulation
WireProtocol.WP_Packet inPacket; // Allocate packet for Pinger input
UInt16 seq = 0; // Initialize Pinger packet sequence number
// While the done button is not pressed
while (buttons.done.Read())
{
Thread.Sleep(10); // No need to respond in a hurry
if (WireProtocol.ReadPacket(pinger, out inPacket))
{
RespondToPacket(pinger, inPacket, seq);
}
}
// Wait for the done button to be released
while (!buttons.done.Read())
{
;
}
}
public void Start(IReceiverCallback callback)
{
_listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, _port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(async s =>
{
using (var stream = new NetworkStream(s, true))
{
await WireProtocol.Receive(stream, callback, Address);
}
});
_receivingLoop = Task.Run(async() =>
{
_listener.Start();
while (!_cancellationToken.IsCancellationRequested)
{
var socket = await _listener.AcceptSocketAsync();
_socketHandling.Post(socket);
}
}, _cancellationToken);
}
internal Message(EndPoint source, WireProtocol.Commands.Debugging_Messaging_Address addr, byte[] payload)
{
m_source = source;
m_addr = addr;
m_payload = payload;
}
public bool SetBreakpoints(WireProtocol.Commands.Debugging_Execution_BreakpointDef[] breakpoints)
{
WireProtocol.Commands.Debugging_Execution_Breakpoints cmd = new WireProtocol.Commands.Debugging_Execution_Breakpoints();
cmd.m_data = breakpoints;
return WireProtocol.IncomingMessage.IsPositiveAcknowledge(SyncMessage(WireProtocol.Commands.c_Debugging_Execution_Breakpoints, 0, cmd));
}
bool WireProtocol.IControllerHostLocal.ProcessMessage(WireProtocol.IncomingMessage msg, bool fReply)
{
msg.Payload = WireProtocol.Commands.ResolveCommandToPayload(msg.Header.m_cmd, fReply, m_capabilities);
if (fReply == true)
{
Request reply = null;
lock (m_requests.SyncRoot)
{
foreach (Request req in m_requests)
{
if (req.MatchesReply(msg))
{
m_requests.Remove(req);
reply = req;
break;
}
}
}
if (reply != null)
{
reply.Signal(msg);
return true;
}
}
else
{
WireProtocol.Packet bp = msg.Header;
switch (bp.m_cmd)
{
case WireProtocol.Commands.c_Monitor_Ping:
{
WireProtocol.Commands.Monitor_Ping.Reply cmdReply = new Microsoft.SPOT.Debugger.WireProtocol.Commands.Monitor_Ping.Reply();
cmdReply.m_source = WireProtocol.Commands.Monitor_Ping.c_Ping_Source_Host;
cmdReply.m_dbg_flags = (m_stopDebuggerOnConnect ? WireProtocol.Commands.Monitor_Ping.c_Ping_DbgFlag_Stop : 0);
msg.Reply(CreateConverter(), WireProtocol.Flags.c_NonCritical, cmdReply);
m_evtPing.Set();
return true;
}
case WireProtocol.Commands.c_Monitor_Message:
{
WireProtocol.Commands.Monitor_Message payload = msg.Payload as WireProtocol.Commands.Monitor_Message;
Debug.Assert(payload != null);
if (payload != null)
{
QueueNotify(m_eventMessage, msg, payload.ToString());
}
return true;
}
case WireProtocol.Commands.c_Debugging_Messaging_Query:
case WireProtocol.Commands.c_Debugging_Messaging_Reply:
case WireProtocol.Commands.c_Debugging_Messaging_Send:
{
Debug.Assert(msg.Payload != null);
if (msg.Payload != null)
{
QueueRpc(msg);
}
return true;
}
}
}
if (m_eventCommand != null)
{
QueueNotify(m_eventCommand, msg, fReply);
return true;
}
return false;
}
// Accepts only a good packet. If the packet is a Ping, the Ping response (ACK) is sent.
// Otherwise, the command is NAK'ed.
static bool RespondToPacket(UsbStream pinger, WireProtocol.WP_Packet inPacket, UInt16 seq)
{
WireProtocol.WP_Packet outPacket = new WireProtocol.WP_Packet();
// Allocate space for any data following the packet
int size = (int)(inPacket.m_size & 0xFFFF);
byte[] buffer = new byte[size];
// Read in the data that came with the packet
if (inPacket.m_size != 0)
pinger.Read(buffer, 0, size);
// Fill in the blanks of the response packet
outPacket.m_signature = "MSdbgV1"; // Standard target signature
outPacket.m_cmd = inPacket.m_cmd; // Show which command this is a response to
outPacket.m_seq = seq++; // Keep track of the target message sequence number
outPacket.m_seqReply = inPacket.m_seq; // Show which host packet sequence number this is a response to
// If the host packet was a Ping
if (inPacket.m_cmd == WireProtocol.Commands.Ping)
{
byte[] data = new byte[8]; // The Ping has an 8 byte data response
outPacket.m_flags = 0x8003; // Return a low-priority ACK
for (int i = 0; i < 8; i++)
data[i] = 0; // Initialize all bytes of the data response to zero
data[0] = 1; // This tells the host that we are TinyBooter
data[4] = 2; // This is an innoccuous flag value
WireProtocol.SendPacket(pinger, outPacket, data); // Send response to the Ping
}
else
{
outPacket.m_flags = 0x4003; // Return a low-priority NACK
WireProtocol.SendPacket(pinger, outPacket, new byte[0]); // Signal to the host that we don't know what to do with the command
}
return true;
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method.
/// It reveives bytes from socker.
/// </summary>
/// <param name="ar">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult ar)
{
if (!_running)
{
return;
}
#if UTILIZA_DESCONEXION_AUTOMATICA
//int valorAnterior = Interlocked.CompareExchange(ref timeoutFlag, 2, 1);
if (Interlocked.CompareExchange(ref timeoutFlag, 2, 1) /*valorAnterior*/ != 0)
{
//El flag ya ha sido seteado con lo cual nada!!
return;
}
if (timerTimeout != null)
{
timerTimeout.Stop();
}
#endif
try
{
//Get received bytes count
var bytesRead = _clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
LastReceivedMessageTime = DateTime.Now;
//Copy received bytes to a new byte array
var receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, 0, receivedBytes, 0, bytesRead);
//Read messages according to current wire protocol
var messages = WireProtocol.CreateMessages(receivedBytes);
//Raise MessageReceived event for all received messages
foreach (var message in messages)
{
OnMessageReceived(message);
}
}
else
{
throw new CommunicationException("Tcp socket is closed");
}
//Read more bytes if still running
if (_running)
{
_clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), null);
#if UTILIZA_DESCONEXION_AUTOMATICA
timerTimeout.Start();
#endif
}
}
catch
{
Disconnect();
}
}
internal void Signal(WireProtocol.IncomingMessage res)
{
lock (this)
{
if (m_timer != null)
{
m_timer.Dispose();
m_timer = null;
}
m_res = res;
}
Signal();
}
internal bool RpcReply(WireProtocol.Commands.Debugging_Messaging_Address addr, byte[] data)
{
WireProtocol.Commands.Debugging_Messaging_Reply cmd = new WireProtocol.Commands.Debugging_Messaging_Reply();
cmd.m_addr = addr;
cmd.m_data = data;
WireProtocol.IncomingMessage reply = SyncMessage(WireProtocol.Commands.c_Debugging_Messaging_Reply, 0, cmd);
if (reply != null)
{
WireProtocol.Commands.Debugging_Messaging_Reply.Reply res = new WireProtocol.Commands.Debugging_Messaging_Reply.Reply();
if (res != null && res.m_found != 0)
{
return true;
}
}
return false;
}
private void RpcReceiveSend(WireProtocol.IncomingMessage msg, WireProtocol.Commands.Debugging_Messaging_Send send)
{
WireProtocol.Commands.Debugging_Messaging_Address addr = send.m_addr;
EndPointRegistration eep;
eep = RpcFind(addr.m_to_Type, addr.m_to_Id, true);
WireProtocol.Commands.Debugging_Messaging_Send.Reply res = new WireProtocol.Commands.Debugging_Messaging_Send.Reply();
res.m_found = (eep != null) ? 1u : 0u;
res.m_addr = addr;
msg.Reply(CreateConverter(), WireProtocol.Flags.c_NonCritical, res);
if (eep != null)
{
Message msgNew = new Message(eep.m_ep, addr, send.m_data);
EndPointRegistration.InboundRequest ir = new EndPointRegistration.InboundRequest(eep, msgNew);
ThreadPool.QueueUserWorkItem(new WaitCallback(RpcReceiveSendDispatch), ir);
}
}
protected internal RuntimeValue_Object( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array, pos )
{
}
protected internal RuntimeValue_Array( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
}
internal bool RpcCheck(WireProtocol.Commands.Debugging_Messaging_Address addr)
{
WireProtocol.Commands.Debugging_Messaging_Query cmd = new WireProtocol.Commands.Debugging_Messaging_Query();
cmd.m_addr = addr;
WireProtocol.IncomingMessage reply = SyncMessage(WireProtocol.Commands.c_Debugging_Messaging_Query, 0, cmd);
if (reply != null)
{
WireProtocol.Commands.Debugging_Messaging_Query.Reply res = reply.Payload as WireProtocol.Commands.Debugging_Messaging_Query.Reply;
if (res != null && res.m_found != 0)
{
return true;
}
}
return false;
}
private void RpcReceiveQuery(WireProtocol.IncomingMessage msg, WireProtocol.Commands.Debugging_Messaging_Query query)
{
WireProtocol.Commands.Debugging_Messaging_Address addr = query.m_addr;
EndPointRegistration eep = RpcFind(addr.m_to_Type, addr.m_to_Id, true);
WireProtocol.Commands.Debugging_Messaging_Query.Reply res = new WireProtocol.Commands.Debugging_Messaging_Query.Reply();
res.m_found = (eep != null) ? 1u : 0u;
res.m_addr = addr;
msg.Reply(CreateConverter(), WireProtocol.Flags.c_NonCritical, res);
}
internal void QueueRpc(WireProtocol.IncomingMessage msg)
{
m_rpcQueue.Add(msg);
m_rpcEvent.Set();
}
internal Request(Engine parent, WireProtocol.OutgoingMessage req, int retries, int timeout, CommandEventHandler callback)
{
if (retries < 0)
{
throw new ArgumentException("Value cannot be negative", "retries");
}
if (timeout < 1 || timeout > 60 * 60 * 1000)
{
throw new ArgumentException(String.Format("Value out of bounds: {0}", timeout), "timeout");
}
m_parent = parent;
m_req = req;
m_retries = retries;
m_timeoutRetry = new TimeSpan(timeout * TimeSpan.TicksPerMillisecond);
m_timeoutWait = new TimeSpan((retries == 0 ? 1 : 2 * retries) * timeout * TimeSpan.TicksPerMillisecond);
m_callback = callback;
if (callback == null)
{
m_event = new ManualResetEvent(false);
}
}
internal bool MatchesReply(WireProtocol.IncomingMessage res)
{
WireProtocol.Packet headerReq = m_req.Header;
WireProtocol.Packet headerRes = res.Header;
if (headerReq.m_cmd == headerRes.m_cmd &&
headerReq.m_seq == headerRes.m_seqReply)
{
return true;
}
return false;
}
private void RpcReceiveReply(WireProtocol.IncomingMessage msg, WireProtocol.Commands.Debugging_Messaging_Reply reply)
{
WireProtocol.Commands.Debugging_Messaging_Address addr = reply.m_addr;
EndPointRegistration eep;
eep = RpcFind(addr.m_from_Type, addr.m_from_Id, false);
WireProtocol.Commands.Debugging_Messaging_Reply.Reply res = new WireProtocol.Commands.Debugging_Messaging_Reply.Reply();
res.m_found = (eep != null) ? 1u : 0u;
res.m_addr = addr;
msg.Reply(CreateConverter(), WireProtocol.Flags.c_NonCritical, res);
if (eep != null)
{
lock (eep.m_req_Outbound.SyncRoot)
{
foreach (EndPointRegistration.OutboundRequest or in eep.m_req_Outbound)
{
if (or.Seq == addr.m_seq && or.Type == addr.m_to_Type && or.Id == addr.m_to_Id)
{
or.Reply = reply.m_data;
break;
}
}
}
}
}
/// <summary>
/// This method is used as callback method in _clientSocket's BeginReceive method.
/// It reveives bytes from socker.
/// </summary>
/// <param name="ar">Asyncronous call result</param>
private void ReceiveCallback(IAsyncResult ar)
{
Socket __clientSocket = ar.AsyncState as Socket;
if (!_running)
{
return;
}
try
{
//Get received bytes count
var bytesRead = __clientSocket.EndReceive(ar);
if (bytesRead > 0)
{
LastReceivedMessageTime = DateTime.Now;
//Copy received bytes to a new byte array
var receivedBytes = new byte[bytesRead];
Array.Copy(_buffer, 0, receivedBytes, 0, bytesRead);
//Read messages according to current wire protocol
var messages = WireProtocol.CreateMessages(receivedBytes);
//Raise MessageReceived event for all received messages
foreach (var message in messages)
{
OnMessageReceived(message);
}
}
else
{
throw new CommunicationException("Tcp socket is closed");
}
//Read more bytes if still running
if (_running)
{
__clientSocket.BeginReceive(_buffer, 0, _buffer.Length, 0, new AsyncCallback(ReceiveCallback), __clientSocket);
}
}
catch (SocketException ex)
{
if ((ex.SocketErrorCode == SocketError.ConnectionReset) ||
(ex.SocketErrorCode == SocketError.ConnectionAborted) ||
(ex.SocketErrorCode == SocketError.NotConnected) ||
(ex.SocketErrorCode == SocketError.Shutdown) ||
(ex.SocketErrorCode == SocketError.Disconnecting))
{
Disconnect();
}
else
{
OnMessageError(ex);
}
}
catch (CommunicationException ex)
{
Disconnect();
}
catch (Exception ex)
{
OnMessageError(ex);
}
}
internal Request AsyncRequest(WireProtocol.OutgoingMessage msg, int retries, int timeout)
{
try
{
Request req = new Request(this, msg, retries, timeout, null);
lock (m_state.SyncObject)
{
//Checking whether IsRunning and adding the request to m_requests
//needs to be atomic to avoid adding a request after the Engine
//has been stopped.
if (!this.IsRunning)
{
throw new ApplicationException("Engine is not running or process has exited.");
}
m_requests.Add(req);
req.SendAsync();
}
return req;
}
catch
{
return null;
}
}
internal WireProtocol.IncomingMessage SyncRequest(WireProtocol.OutgoingMessage msg, int retries, int timeout)
{
/// Lock on m_ReqSyncLock object, so only one thread is active inside the block.
lock (m_ReqSyncLock)
{
Request req = AsyncRequest(msg, retries, timeout);
return req != null ? req.Wait() : null;
}
}
private WireProtocol.IncomingMessage[] SyncMessages(WireProtocol.OutgoingMessage[] messages, int retries, int timeout)
{
int cMessage = messages.Length;
WireProtocol.IncomingMessage[] replies = new WireProtocol.IncomingMessage[cMessage];
Request[] requests = new Request[cMessage];
for (int iMessage = 0; iMessage < cMessage; iMessage++)
{
replies[iMessage] = SyncRequest(messages[iMessage], retries, timeout);
}
return replies;
}
private static void DebugDump(WireProtocol.IncomingMessage m, string text)
{
}
private WireProtocol.IncomingMessage[] SyncMessages(WireProtocol.OutgoingMessage[] messages)
{
return SyncMessages(messages, 2, 1000);
}
internal byte[] RpcSend(WireProtocol.Commands.Debugging_Messaging_Address addr, int timeout, byte[] data)
{
EndPointRegistration.OutboundRequest or = null;
byte[] res = null;
try
{
or = RpcSend_Setup(addr, data);
if (or != null)
{
or.WaitHandle.WaitOne(timeout, false);
res = or.Reply;
}
}
finally
{
if (or != null)
{
or.Owner.m_req_Outbound.Remove(or);
}
}
return res;
}
protected internal RuntimeValue_Reflection( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
m_rd = (ReflectionDefinition)System.Runtime.Serialization.FormatterServices.GetUninitializedObject( typeof(ReflectionDefinition) );
m_eng.CreateConverter().Deserialize( m_rd, handle.m_builtinValue );
}
public void SetController(WireProtocol.IController ctrl)
{
if (m_ctrl != null)
{
throw new ArgumentException("Controller already initialized");
}
if (ctrl == null)
{
throw new ArgumentNullException("ctrl");
}
m_ctrl = ctrl;
}
private EndPointRegistration.OutboundRequest RpcSend_Setup(WireProtocol.Commands.Debugging_Messaging_Address addr, byte[] data)
{
EndPointRegistration eep = RpcFind(addr.m_from_Type, addr.m_from_Id, false);
EndPointRegistration.OutboundRequest or = null;
if (eep != null)
{
bool fSuccess = false;
or = new EndPointRegistration.OutboundRequest(eep, addr.m_seq, addr.m_to_Type, addr.m_to_Id);
try
{
eep.m_req_Outbound.Add(or);
WireProtocol.Commands.Debugging_Messaging_Send cmd = new WireProtocol.Commands.Debugging_Messaging_Send();
cmd.m_addr = addr;
cmd.m_data = data;
WireProtocol.IncomingMessage reply = SyncMessage(WireProtocol.Commands.c_Debugging_Messaging_Send, 0, cmd);
if (reply != null)
{
WireProtocol.Commands.Debugging_Messaging_Send.Reply res = reply.Payload as WireProtocol.Commands.Debugging_Messaging_Send.Reply;
if (res != null && res.m_found != 0)
{
fSuccess = true;
}
}
}
catch
{
}
if (!this.IsRunning)
{
fSuccess = false;
}
if (!fSuccess)
{
eep.m_req_Outbound.Remove(or);
or = null;
}
}
return or;
}
