/// <summary>Iteratively disassemble source code.</summary> /// <param name="callback">A delegate that will be invoked on each disassembled /// instruction.</param> public void Disassemble(byte[] code, IterativeDisassemblyDelegate callback) { bool shouldContinue = true; ulong address = DefaultStartAddress; int totalSize = 0; IntPtr nativeCode = IntPtr.Zero; try { IntPtr nativeInstruction = IntPtr.Zero; using (SafeNativeInstructionHandle hInstruction = CapstoneImport.AllocateInstruction(this)) { nativeInstruction = hInstruction.DangerousGetHandle(); // Transfer the managed byte array into a native buffer. nativeCode = Marshal.AllocCoTaskMem(code.Length); Marshal.Copy(code, 0, nativeCode, code.Length); IntPtr remainingSize = (IntPtr)code.Length; do { if (hInstruction.IsClosed) { throw new ApplicationException(); } ulong instructionStartAddress = address; shouldContinue |= CapstoneImport.DisassembleIteratively(this, ref nativeCode, ref remainingSize, ref address, hInstruction); if (shouldContinue) { int instructionSize = (int)(address - instructionStartAddress); totalSize += instructionSize; shouldContinue |= callback(NativeInstruction.Create(this, ref nativeInstruction), instructionSize, address); } } while (shouldContinue && (0 < (long)remainingSize)); // TODO : Consider releasing nativeInstruction handle. if (hInstruction.IsClosed) { throw new ApplicationException(); } hInstruction.Dispose(); } } finally { if (IntPtr.Zero != nativeCode) { Marshal.FreeCoTaskMem(nativeCode); } } }
public IntPtr MarshalManagedToNative(object ManagedObj) { SafeNativeInstructionHandle instructionHandle = (SafeNativeInstructionHandle)ManagedObj; if (null == instructionHandle) { return(IntPtr.Zero); } if (_enforecFreeingLock) { if (SafeNativeInstructionHandle._beingFreed != instructionHandle) { throw new InvalidOperationException(); } } return(instructionHandle.handle); }
internal static extern void Free( [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeNativeInstructionHandle.Marshaler), MarshalCookie = SafeNativeInstructionHandle.Marshaler.FreeMarshalerCookie)] SafeNativeInstructionHandle instructions, [In] IntPtr instructionCount);
/// <summary>Release Handle.</summary> /// <returns>A boolean true if the handle was released. A boolean false /// otherwise.</returns> protected override bool ReleaseHandle() { lock (ReleaseLock) { try { _beingFreed = this; CapstoneImport.Free(this, this._instructionCount); } finally { _beingFreed = null; } } this._instructions = Enumerable.Empty<NativeInstruction>(); return true; }
internal static extern bool DisassembleIteratively( [In] SafeCapstoneContextHandle pHandle, [In, Out] ref IntPtr /* uint8_t ** */ code, [In, Out] ref IntPtr codeSize, [In, Out] ref ulong address, [In] SafeNativeInstructionHandle /* cs_insn * */ insn);