public static void CopyShallow(object source, object target) { if (source == null) { throw new ArgumentNullException("source"); } if (target == null) { throw new ArgumentNullException("target"); } Type t = source.GetType(); if (target.GetType() != t) { throw new ArgumentException("Object types must be equal."); } byte[] data = new byte[UnsafeTools.BaseInstanceSizeOf(t) - IntPtr.Size]; InteropTools.Pin( source, o1 => { var ptr = UnsafeTools.GetAddress(o1); Marshal.Copy(ptr, data, 0, data.Length); } ); InteropTools.Pin( target, o2 => { var ptr = UnsafeTools.GetAddress(o2); Marshal.Copy(data, 0, ptr, data.Length); } ); }
static StackAllocated() { if (InteropTools.ContainsReferences <T>()) { throw new InvalidOperationException("Allocating types that contain references on the stack is not supported."); } if (type.IsArray || type == TypeOf <string> .TypeID) { throw new InvalidOperationException("Variable-sized instances aren't supported."); } }
public static IntPtr Rva2Offset(uint dwRva, IntPtr PEPointer) { bool is64Bit = false; ushort wIndex = 0; ushort wNumberOfSections = 0; IntPtr imageSectionPtr; IMAGE_SECTION_HEADER SectionHeader; int sizeOfSectionHeader = Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)); IMAGE_DOS_HEADER dosHeader = InteropTools.PtrToStructure <IMAGE_DOS_HEADER>(PEPointer); IntPtr NtHeadersPtr = (IntPtr)((UInt64)PEPointer + (UInt64)dosHeader.e_lfanew); var imageNtHeaders32 = (IMAGE_NT_HEADERS)Marshal.PtrToStructure(NtHeadersPtr, typeof(IMAGE_NT_HEADERS)); var imageNtHeaders64 = (IMAGE_NT_HEADERS64)Marshal.PtrToStructure(NtHeadersPtr, typeof(IMAGE_NT_HEADERS64)); if (imageNtHeaders64.OptionalHeader.Magic == MagicType.IMAGE_NT_OPTIONAL_HDR64_MAGIC) { is64Bit = true; } if (is64Bit) { imageSectionPtr = (IntPtr)(((Int64)NtHeadersPtr + (Int64)Marshal.OffsetOf(typeof(IMAGE_NT_HEADERS64), "OptionalHeader") + (Int64)imageNtHeaders64.FileHeader.SizeOfOptionalHeader)); SectionHeader = (IMAGE_SECTION_HEADER)Marshal.PtrToStructure(imageSectionPtr, typeof(IMAGE_SECTION_HEADER)); wNumberOfSections = imageNtHeaders64.FileHeader.NumberOfSections; } else { imageSectionPtr = (IntPtr)(((Int64)NtHeadersPtr + (Int64)Marshal.OffsetOf(typeof(IMAGE_NT_HEADERS), "OptionalHeader") + (Int64)imageNtHeaders32.FileHeader.SizeOfOptionalHeader)); SectionHeader = (IMAGE_SECTION_HEADER)Marshal.PtrToStructure(imageSectionPtr, typeof(IMAGE_SECTION_HEADER)); wNumberOfSections = imageNtHeaders32.FileHeader.NumberOfSections; } if (dwRva < SectionHeader.PointerToRawData) { return((IntPtr)((UInt64)dwRva + (UInt64)PEPointer)); } for (wIndex = 0; wIndex < wNumberOfSections; wIndex++) { SectionHeader = (IMAGE_SECTION_HEADER)Marshal.PtrToStructure((IntPtr)((uint)imageSectionPtr + (uint)(sizeOfSectionHeader * (wIndex))), typeof(IMAGE_SECTION_HEADER)); if (dwRva >= SectionHeader.VirtualAddress && dwRva < (SectionHeader.VirtualAddress + SectionHeader.SizeOfRawData)) { return((IntPtr)((UInt64)(dwRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData) + (UInt64)PEPointer)); } } return(IntPtr.Zero); }
public static unsafe int GetOffset(this FieldInfo field) { return(InteropTools.Pin( FormatterServices.GetUninitializedObject(field.DeclaringType), delegate(object inst) { TypedReference tr0, tr1; TypedReferenceTools.MakeTypedReference(&tr0, inst); TypedReferenceTools.MakeTypedReference(&tr1, inst, field); byte *p0 = (byte *)tr0.ToPointer(); byte *p1 = (byte *)tr1.ToPointer(); return (int)(p1 - p0); } )); }
public static void Write <T>(this Stream output, IEnumerable <T> structures) where T : struct { Type t = typeof(T); int size = Marshal.SizeOf(t); byte[] buffer = new byte[size]; IntPtr ptr = Marshal.AllocHGlobal(size); try{ foreach (var s in structures) { InteropTools.StructureToPtr(s, ptr); Marshal.Copy(ptr, buffer, 0, size); output.Write(buffer, 0, size); } }finally{ Marshal.FreeHGlobal(ptr); } }
private static IEnumerable <T> EnumerateStructures <T>(Stream input) where T : struct { Type t = TypeOf <T> .TypeID; int size = Marshal.SizeOf(t); byte[] buffer = new byte[size]; IntPtr ptr = Marshal.AllocHGlobal(size); try{ while (input.Read(buffer, 0, size) == size) { Marshal.Copy(buffer, 0, ptr, size); yield return(InteropTools.PtrToStructure <T>(ptr)); } throw new EndOfStreamException(); }finally{ Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Pins an object in a memory and constructs its pin handle. /// </summary> /// <param name="obj">The object to pin.</param> public ObjectPinHandle(object obj) { Object = obj; using (var re1 = new AutoResetEvent(false)) { var thr = new Thread( delegate() { InteropTools.Pin( obj, delegate { re1.Set(); Reset.WaitOne(); } ); } ); thr.Start(); re1.WaitOne(); } }
public static void Write(this Stream output, __arglist) { ArgIterator iter = new ArgIterator(__arglist); try{ while (iter.GetRemainingCount() > 0) { TypedReference tr = iter.GetNextArg(); Type t = __reftype(tr); int size = Marshal.SizeOf(t); byte[] buffer = new byte[size]; IntPtr ptr = Marshal.AllocHGlobal(size); try{ InteropTools.StructureToPtrDirect(tr, ptr, size); Marshal.Copy(ptr, buffer, 0, size); output.Write(buffer, 0, size); }finally{ Marshal.FreeHGlobal(ptr); } } }finally{ iter.End(); } }