mirror of
https://github.com/reactos/reactosdbg.git
synced 2024-11-23 03:39:43 +00:00
9868a9e7f5
- KDBG/IDebugProtocol: parse/add/delete/enable/disable breakpoints. Some other refactorings done to reduce method size. - Dockable window that shows current list of breakpoints with add/delete/edit button (you can also double-click to edit). Breakpoints can easily be enabled/disabled with a checkbox. - Dialog window to add or edit breakpoint details. GUI tries to prevent invalid input. - Add svn:ignore to RosDBG directory. svn path=/trunk/reactosdbg/; revision=1308
619 lines
24 KiB
C#
619 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Globalization;
|
|
using AbstractPipe;
|
|
using DebugProtocol;
|
|
using System.Diagnostics;
|
|
|
|
namespace KDBGProtocol
|
|
{
|
|
public class KDBG : IDebugProtocol
|
|
{
|
|
#region Regular expressions
|
|
static Regex mMemoryRowUpdate = new Regex("<(?<addr>[^>]+)>: (?<row>[0-9a-fA-F? ]*)");
|
|
static Regex mModuleOffset = new Regex("(?<modname>[^:]+):(?<offset>[0-9a-fA-f]+).*");
|
|
static Regex mModuleUpdate = new Regex("(?<base>[0-9a-fA-F]+) (?<size>[0-9a-fA-F]+) (?<modname>\\w+\\.\\w+)");
|
|
static Regex mRegLineCS_EIP = new Regex("CS:EIP 0x(?<cs>[0-9a-fA-F]+):0x(?<eip>[0-9a-fA-F]+).*");
|
|
static Regex mRegLineSS_ESP = new Regex("SS:ESP 0x(?<ss>[0-9a-fA-F]+):0x(?<esp>[0-9a-fA-F]+).*");
|
|
static Regex mRegLineEAX_EBX = new Regex("EAX 0x(?<eax>[0-9a-fA-F]+)[ \t]+EBX 0x(?<ebx>[0-9a-fA-F]+).*");
|
|
static Regex mRegLineECX_EDX = new Regex("ECX 0x(?<ecx>[0-9a-fA-F]+)[ \t]+EDX 0x(?<edx>[0-9a-fA-F]+).*");
|
|
static Regex mRegLineEBP = new Regex("EBP 0x(?<ebp>[0-9a-fA-F]+).*");
|
|
static Regex mRegLineEFLAGS = new Regex("EFLAGS 0x(?<eflags>[0-9a-fA-F]+).*");
|
|
static Regex mSregLine = new Regex("[CDEFGS]S 0x(?<seg>[0-9a-fA-F]+).*");
|
|
static Regex mProcListHeading = new Regex("PID[ \\t]+State[ \\t]+Filename.*");
|
|
static Regex mThreadListHeading = new Regex("TID[ \\t]+State[ \\t]+Prio.*");
|
|
static Regex mProcListEntry = new Regex("^(?<cur>([*]|))0x(?<pid>[0-9a-fA-F]+)[ \\t](?<state>[a-zA-Z ]+)[ \\t](?<name>[a-zA-Z. ]+).*");
|
|
static Regex mThreadListEntry = new Regex("^(?<cur>([*]|))0x(?<tid>[0-9a-fA-F]+)[ \\t]+(?<state>.*)0x(?<eip>[0-9a-fA-F]*)");
|
|
static Regex mBreakpointListEntry = new Regex("^\\*?(?<id>[0-9]{3})[ \\t]+(?<type>BP[X|M])[ \\t]+0x(?<address>[0-9a-fA-F]+)(?<rest>.+)");
|
|
#endregion
|
|
|
|
#region Fields
|
|
bool mRunning = true;
|
|
Pipe mConnection;
|
|
Queue<string> mCommandBuffer = new Queue<string>();
|
|
Dictionary<string, ulong> mModuleList = new Dictionary<string, ulong>();
|
|
ulong[] mRegisters = new ulong[32];
|
|
IList<Breakpoint> mBreakpoints = new List<Breakpoint>();
|
|
|
|
bool mFirstModuleUpdate = false;
|
|
bool mReceivingProcs = false;
|
|
bool mReceivingThreads = false;
|
|
bool mReceivingBreakpoints = false;
|
|
StringBuilder mInputBuffer = new StringBuilder();
|
|
int mUsedInput;
|
|
#endregion
|
|
|
|
#region Events
|
|
public event ConsoleOutputEventHandler ConsoleOutputEvent;
|
|
public event RegisterChangeEventHandler RegisterChangeEvent;
|
|
public event BreakpointChangeEventHandler BreakpointChangeEvent;
|
|
public event SignalDeliveredEventHandler SignalDeliveredEvent;
|
|
public event RemoteGDBErrorHandler RemoteGDBError;
|
|
public event MemoryUpdateEventHandler MemoryUpdateEvent;
|
|
public event ModuleListEventHandler ModuleListEvent;
|
|
public event ProcessListEventHandler ProcessListEvent;
|
|
public event ThreadListEventHandler ThreadListEvent;
|
|
#endregion
|
|
|
|
public KDBG(Pipe connection)
|
|
{
|
|
mConnection = connection;
|
|
mConnection.PipeReceiveEvent += PipeReceiveEvent;
|
|
mConnection.PipeErrorEvent += PipeErrorEvent;
|
|
}
|
|
|
|
#region Event handlers
|
|
void PipeErrorEvent(object sender, PipeErrorEventArgs args)
|
|
{
|
|
}
|
|
|
|
void PipeReceiveEvent(object sender, PipeReceiveEventArgs args)
|
|
{
|
|
bool tookText = false;
|
|
string inbufStr;
|
|
int promptIdx;
|
|
|
|
mInputBuffer.Append(args.Received);
|
|
|
|
if (mInputBuffer.ToString().Substring(mUsedInput).Contains("key to continue"))
|
|
{
|
|
mConnection.Write("\r");
|
|
mUsedInput = mInputBuffer.Length;
|
|
}
|
|
|
|
while ((promptIdx = (inbufStr = mInputBuffer.ToString()).IndexOf("kdb:> ")) != -1)
|
|
{
|
|
string pretext = inbufStr.Substring(0, promptIdx);
|
|
string[] theInput = pretext.Split(new char[] { '\n' });
|
|
int remove = pretext.Length + "kdb:> ".Length;
|
|
|
|
mInputBuffer.Remove(0, remove);
|
|
mUsedInput = Math.Max(0, mUsedInput - remove);
|
|
|
|
if (!tookText)
|
|
{
|
|
if (mRunning)
|
|
{
|
|
mRunning = false;
|
|
}
|
|
tookText = true;
|
|
}
|
|
|
|
foreach (string line in theInput)
|
|
{
|
|
string cleanedLine = line.Trim();
|
|
try
|
|
{
|
|
if (cleanedLine.Contains("Entered debugger on "))
|
|
{
|
|
mReceivingProcs = false;
|
|
mReceivingThreads = false;
|
|
GetRegisterUpdate();
|
|
GetProcesses();
|
|
continue;
|
|
}
|
|
|
|
if (!mFirstModuleUpdate)
|
|
{
|
|
GetModuleUpdate();
|
|
mFirstModuleUpdate = true;
|
|
}
|
|
|
|
if (TryParseMemory(cleanedLine)) continue;
|
|
if (TryParseModule(cleanedLine)) continue;
|
|
if (TryParseRegisters(cleanedLine)) continue;
|
|
if (TryParseSegmentRegisters(cleanedLine)) continue;
|
|
if (TryParsePID(cleanedLine)) continue;
|
|
if (TryParseTID(cleanedLine)) continue;
|
|
if (TryParseBreakpoint(cleanedLine)) continue;
|
|
}
|
|
catch (Exception) { /* Error line ... we'll ignore it for now */ }
|
|
}
|
|
}
|
|
|
|
if (tookText)
|
|
{
|
|
lock (mCommandBuffer)
|
|
{
|
|
if (mCommandBuffer.Count > 0)
|
|
{
|
|
string firstCommand = mCommandBuffer.Dequeue();
|
|
mConnection.Write(firstCommand + "\r");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Individual parsing methods, each one looking for a specific item
|
|
private bool TryParseMemory(string cleanedLine)
|
|
{
|
|
Match memoryMatch = mMemoryRowUpdate.Match(cleanedLine);
|
|
if (memoryMatch.Success)
|
|
{
|
|
string addrStr = memoryMatch.Groups["addr"].ToString();
|
|
Match modOffset = mModuleOffset.Match(addrStr);
|
|
ulong updateAddress;
|
|
if (modOffset.Success)
|
|
{
|
|
string modname = modOffset.Groups["modname"].ToString();
|
|
ulong offset = ulong.Parse(modOffset.Groups["offset"].ToString(), NumberStyles.HexNumber);
|
|
ulong modbase;
|
|
if (mModuleList.TryGetValue(modname.ToUpper(), out modbase))
|
|
updateAddress = modbase + offset;
|
|
else
|
|
return true; // Couldn't resolve the address of the named module ...
|
|
}
|
|
else
|
|
{
|
|
updateAddress = ulong.Parse(addrStr, NumberStyles.HexNumber);
|
|
}
|
|
string[] memWords = memoryMatch.Groups["row"].ToString().Split(new char[] { ' ' });
|
|
byte[] updateBytes = new byte[4 * memWords.Length];
|
|
int ctr = 0;
|
|
foreach (string word in memWords)
|
|
{
|
|
if (word[0] == '?')
|
|
{
|
|
if (MemoryUpdateEvent != null)
|
|
MemoryUpdateEvent(this, new MemoryUpdateEventArgs((updateAddress & ~0xfffUL), null));
|
|
}
|
|
else
|
|
{
|
|
int wordParsed = int.Parse(word, NumberStyles.HexNumber);
|
|
int curCtr = ctr;
|
|
for (ctr = curCtr; ctr < curCtr + 4; ctr++)
|
|
{
|
|
updateBytes[ctr] = (byte)(wordParsed & 0xff);
|
|
wordParsed >>= 8;
|
|
}
|
|
}
|
|
}
|
|
if (MemoryUpdateEvent != null)
|
|
MemoryUpdateEvent(this, new MemoryUpdateEventArgs(updateAddress, updateBytes));
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParseModule(string cleanedLine)
|
|
{
|
|
Match moduleMatch = mModuleUpdate.Match(cleanedLine);
|
|
if (moduleMatch.Success)
|
|
{
|
|
ulong baseAddress = ulong.Parse(moduleMatch.Groups["base"].ToString(), NumberStyles.HexNumber);
|
|
uint moduleSize = uint.Parse(moduleMatch.Groups["size"].ToString(), NumberStyles.HexNumber);
|
|
string moduleName = moduleMatch.Groups["modname"].ToString();
|
|
mModuleList[moduleName.ToUpper()] = baseAddress;
|
|
if (ModuleListEvent != null)
|
|
ModuleListEvent(this, new ModuleListEventArgs(moduleName, baseAddress));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParseRegisters(string cleanedLine)
|
|
{
|
|
Match csEipMatch = mRegLineCS_EIP.Match(cleanedLine);
|
|
if (csEipMatch.Success)
|
|
{
|
|
uint cs = uint.Parse(csEipMatch.Groups["cs"].ToString(), NumberStyles.HexNumber);
|
|
ulong eip = ulong.Parse(csEipMatch.Groups["eip"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[8] = eip;
|
|
mRegisters[10] = cs;
|
|
return true;
|
|
}
|
|
|
|
Match ssEspMatch = mRegLineSS_ESP.Match(cleanedLine);
|
|
if (ssEspMatch.Success)
|
|
{
|
|
uint ss = uint.Parse(ssEspMatch.Groups["ss"].ToString(), NumberStyles.HexNumber);
|
|
ulong esp = ulong.Parse(ssEspMatch.Groups["esp"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[4] = esp;
|
|
mRegisters[15] = ss;
|
|
return true;
|
|
}
|
|
|
|
Match eaxEbxMatch = mRegLineEAX_EBX.Match(cleanedLine);
|
|
if (eaxEbxMatch.Success)
|
|
{
|
|
ulong eax = ulong.Parse(eaxEbxMatch.Groups["eax"].ToString(), NumberStyles.HexNumber);
|
|
ulong ebx = ulong.Parse(eaxEbxMatch.Groups["ebx"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[0] = eax;
|
|
mRegisters[3] = ebx;
|
|
return true;
|
|
}
|
|
|
|
Match ecxEdxMatch = mRegLineECX_EDX.Match(cleanedLine);
|
|
if (ecxEdxMatch.Success)
|
|
{
|
|
ulong ecx = ulong.Parse(ecxEdxMatch.Groups["ecx"].ToString(), NumberStyles.HexNumber);
|
|
ulong edx = ulong.Parse(ecxEdxMatch.Groups["edx"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[1] = ecx;
|
|
mRegisters[2] = edx;
|
|
return true;
|
|
}
|
|
|
|
Match ebpMatch = mRegLineEBP.Match(cleanedLine);
|
|
if (ebpMatch.Success)
|
|
{
|
|
ulong ebp = ulong.Parse(ebpMatch.Groups["ebp"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[5] = ebp;
|
|
return true;
|
|
}
|
|
|
|
Match eflagsMatch = mRegLineEFLAGS.Match(cleanedLine);
|
|
if (eflagsMatch.Success)
|
|
{
|
|
ulong eflags = ulong.Parse(eflagsMatch.Groups["eflags"].ToString(), NumberStyles.HexNumber);
|
|
mRegisters[9] = eflags;
|
|
if (RegisterChangeEvent != null)
|
|
RegisterChangeEvent(this, new RegisterChangeEventArgs(mRegisters));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParseSegmentRegisters(string cleanedLine)
|
|
{
|
|
Match sregMatch = mSregLine.Match(cleanedLine);
|
|
if (sregMatch.Success)
|
|
{
|
|
char[] segmap = new char[] { 'C', 'D', 'E', 'F', 'G', 'S' };
|
|
uint sreg = uint.Parse(sregMatch.Groups["seg"].ToString(), NumberStyles.HexNumber);
|
|
int findSeg;
|
|
for (findSeg = 0; findSeg < segmap.Length; findSeg++)
|
|
{
|
|
if (segmap[findSeg] == cleanedLine[0])
|
|
{
|
|
mRegisters[10 + findSeg] = sreg;
|
|
if (segmap[findSeg] == 'S' && RegisterChangeEvent != null)
|
|
RegisterChangeEvent(this, new RegisterChangeEventArgs(mRegisters));
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParsePID(string cleanedLine)
|
|
{
|
|
Match pidHeadMatch = mProcListHeading.Match(cleanedLine);
|
|
if (pidHeadMatch.Success)
|
|
{
|
|
mReceivingThreads = false;
|
|
mReceivingProcs = true;
|
|
if (ProcessListEvent != null)
|
|
ProcessListEvent(this, new ProcessListEventArgs());
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Match pidEntryMatch = mProcListEntry.Match(cleanedLine);
|
|
if (pidEntryMatch.Success && mReceivingProcs)
|
|
{
|
|
if (ProcessListEvent != null)
|
|
ProcessListEvent(this, new ProcessListEventArgs(ulong.Parse(pidEntryMatch.Groups["pid"].ToString(), NumberStyles.HexNumber), pidEntryMatch.Groups["cur"].Length > 0,
|
|
pidEntryMatch.Groups["state"].ToString(), pidEntryMatch.Groups["name"].ToString()));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if ((mReceivingProcs || cleanedLine.Contains("No processes")) && ProcessListEvent != null)
|
|
{
|
|
ProcessListEvent(this, new ProcessListEventArgs(true));
|
|
mReceivingProcs = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParseTID(string cleanedLine)
|
|
{
|
|
Match tidHeadMatch = mThreadListHeading.Match(cleanedLine);
|
|
if (tidHeadMatch.Success)
|
|
{
|
|
mReceivingThreads = true;
|
|
mReceivingProcs = false;
|
|
if (ThreadListEvent != null)
|
|
ThreadListEvent(this, new ThreadListEventArgs());
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Match tidEntryMatch = mThreadListEntry.Match(cleanedLine);
|
|
if (tidEntryMatch.Success && mReceivingThreads)
|
|
{
|
|
if (ThreadListEvent != null)
|
|
ThreadListEvent(this, new ThreadListEventArgs(ulong.Parse(tidEntryMatch.Groups["tid"].ToString(), NumberStyles.HexNumber), tidEntryMatch.Groups["cur"].Length > 0, ulong.Parse(tidEntryMatch.Groups["eip"].ToString(), NumberStyles.HexNumber)));
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (mReceivingThreads && ThreadListEvent != null)
|
|
{
|
|
ThreadListEvent(this, new ThreadListEventArgs(true));
|
|
mReceivingThreads = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool TryParseBreakpoint(string cleanedLine)
|
|
{
|
|
if (cleanedLine.Equals("Breakpoints:")) // Start looking for breakpoint data
|
|
{
|
|
mReceivingBreakpoints = true;
|
|
return true;
|
|
}
|
|
else if (cleanedLine.Equals("No breakpoints.")) // Nothing present
|
|
{
|
|
mReceivingBreakpoints = false;
|
|
mBreakpoints.Clear();
|
|
if (BreakpointChangeEvent != null)
|
|
BreakpointChangeEvent(this, new BreakpointChangeEventArgs(mBreakpoints));
|
|
return true;
|
|
}
|
|
else if (mReceivingBreakpoints)
|
|
{
|
|
Match breakpointMatch = mBreakpointListEntry.Match(cleanedLine);
|
|
if (breakpointMatch.Success)
|
|
{
|
|
// Process breakpoint data
|
|
int id = int.Parse(breakpointMatch.Groups["id"].ToString(), NumberStyles.Integer);
|
|
Breakpoint bp = new Breakpoint(id);
|
|
|
|
string type = breakpointMatch.Groups["type"].ToString();
|
|
bp.Address = ulong.Parse(breakpointMatch.Groups["address"].ToString(), NumberStyles.HexNumber);
|
|
bp.Enabled = true;
|
|
bp.Condition = string.Empty;
|
|
|
|
string rest = breakpointMatch.Groups["rest"].ToString();
|
|
int cond_start = rest.LastIndexOf("IF");
|
|
if (cond_start >= 0) // Separate the condition from the other properties
|
|
{
|
|
bp.Condition = rest.Substring(cond_start + 2).Trim();
|
|
rest = rest.Substring(0, cond_start);
|
|
}
|
|
|
|
string[] properties = rest.Split(' ');
|
|
foreach (string property in properties)
|
|
{
|
|
if (type.Equals("BPM"))
|
|
{
|
|
if (property.Equals("read"))
|
|
bp.BreakpointType = Breakpoint.BPType.ReadWatch;
|
|
else if (property.Equals("write"))
|
|
bp.BreakpointType = Breakpoint.BPType.WriteWatch;
|
|
else if (property.Equals("rdwr"))
|
|
bp.BreakpointType = Breakpoint.BPType.AccessWatch;
|
|
else if (property.Equals("exec"))
|
|
bp.BreakpointType = Breakpoint.BPType.Hardware;
|
|
else if (property.Equals("byte"))
|
|
bp.Length = 1;
|
|
else if (property.Equals("word"))
|
|
bp.Length = 2;
|
|
else if (property.Equals("dword"))
|
|
bp.Length = 4;
|
|
}
|
|
else if (type.Equals("BPX"))
|
|
{
|
|
bp.BreakpointType = Breakpoint.BPType.Software;
|
|
}
|
|
|
|
// Common properties
|
|
if (property.Equals("disabled"))
|
|
bp.Enabled = false;
|
|
}
|
|
|
|
mBreakpoints.Add(bp);
|
|
return true;
|
|
}
|
|
else // Something else; it implies that we've got all the breakpoint data
|
|
{
|
|
if (BreakpointChangeEvent != null)
|
|
BreakpointChangeEvent(this, new BreakpointChangeEventArgs(mBreakpoints));
|
|
mBreakpoints.Clear();
|
|
mReceivingBreakpoints = false;
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
#region Upstream commands
|
|
public void QueueCommand(string command)
|
|
{
|
|
lock (mCommandBuffer)
|
|
{
|
|
mCommandBuffer.Enqueue(command);
|
|
}
|
|
}
|
|
|
|
public void Write(string wr)
|
|
{
|
|
/* Forward user input from RawTraffic if connected to kdbg */
|
|
if (!mRunning)
|
|
{
|
|
mConnection.Write(wr + "\r");
|
|
}
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Immediately executed commands
|
|
public void Step()
|
|
{
|
|
Write("step");
|
|
GetRegisterUpdate();
|
|
GetModuleUpdate();
|
|
GetProcesses();
|
|
}
|
|
|
|
public void Next()
|
|
{
|
|
Write("next");
|
|
Thread.Sleep(100);
|
|
GetRegisterUpdate();
|
|
GetModuleUpdate();
|
|
GetProcesses();
|
|
}
|
|
|
|
public void Break()
|
|
{
|
|
Write("");
|
|
GetRegisterUpdate();
|
|
GetModuleUpdate();
|
|
}
|
|
|
|
public void Go(ulong address)
|
|
{
|
|
Write("cont");
|
|
mRunning = true;
|
|
mFirstModuleUpdate = false;
|
|
}
|
|
|
|
public void GetBreakpoints()
|
|
{
|
|
Write("bl");
|
|
}
|
|
|
|
public void SetBreakpoint(Breakpoint bp)
|
|
{
|
|
string length = "byte";
|
|
if (bp.Length == 2) length = "word";
|
|
else if (bp.Length == 4) length = "dword";
|
|
|
|
StringBuilder command = new StringBuilder();
|
|
|
|
switch (bp.BreakpointType)
|
|
{
|
|
case Breakpoint.BPType.Software:
|
|
command.AppendFormat("bpx 0x{0:x8}", bp.Address);
|
|
break;
|
|
case Breakpoint.BPType.Hardware:
|
|
command.AppendFormat("bpm x {0} 0x{1:x8}", "byte", bp.Address);
|
|
break;
|
|
case Breakpoint.BPType.ReadWatch:
|
|
command.AppendFormat("bpm r {0} 0x{1:x8}", length, bp.Address);
|
|
break;
|
|
case Breakpoint.BPType.WriteWatch:
|
|
command.AppendFormat("bpm w {0} 0x{1:x8}", length, bp.Address);
|
|
break;
|
|
case Breakpoint.BPType.AccessWatch:
|
|
command.AppendFormat("bpm rw {0} 0x{1:x8}", length, bp.Address);
|
|
break;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(bp.Condition))
|
|
command.AppendFormat(" IF {0}", bp.Condition);
|
|
|
|
Write(command.ToString());
|
|
GetBreakpoints();
|
|
}
|
|
|
|
public void RemoveBreakpoint(int id)
|
|
{
|
|
if (id >= 0)
|
|
Write("bc " + id);
|
|
GetBreakpoints();
|
|
}
|
|
|
|
public void EnableBreakpoint(int id)
|
|
{
|
|
if (id >= 0)
|
|
Write("be " + id);
|
|
GetBreakpoints();
|
|
}
|
|
|
|
public void DisableBreakpoint(int id)
|
|
{
|
|
if (id >= 0)
|
|
Write("bd " + id);
|
|
GetBreakpoints();
|
|
}
|
|
|
|
public void WriteMemory(ulong address, byte[] buf)
|
|
{
|
|
}
|
|
|
|
public void GetMemoryUpdate(ulong address, int len)
|
|
{
|
|
Write(string.Format("x 0x{0:X} L {1}", address, len));
|
|
}
|
|
#endregion
|
|
|
|
#region Commands placed into the command queue
|
|
public void GetProcesses()
|
|
{
|
|
QueueCommand("proc list");
|
|
}
|
|
|
|
public void GetThreads(ulong pid)
|
|
{
|
|
if (pid != 0)
|
|
QueueCommand(string.Format("thread list 0x{0:X8}", pid));
|
|
}
|
|
|
|
public void SetProcess(ulong pid)
|
|
{
|
|
QueueCommand(string.Format("proc attach 0x{0:X8}", pid));
|
|
GetRegisterUpdate();
|
|
}
|
|
|
|
public void SetThread(ulong tid)
|
|
{
|
|
QueueCommand(string.Format("thread attach 0x{0:X8}", tid));
|
|
GetRegisterUpdate();
|
|
}
|
|
|
|
public void GetRegisterUpdate()
|
|
{
|
|
QueueCommand("regs");
|
|
QueueCommand("sregs");
|
|
}
|
|
|
|
public void GetModuleUpdate()
|
|
{
|
|
QueueCommand("mod");
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|