private static uint FindEntryPoint(IntPtr hProcess, IntPtr hModule) { if (hProcess.IsNull() || hProcess.Compare(-1L)) { throw new ArgumentException("Invalid process handle.", "hProcess"); } if (hModule.IsNull()) { throw new ArgumentException("Invalid module handle.", "hModule"); } byte[] array = WinAPI.ReadRemoteMemory(hProcess, hModule, (uint)Marshal.SizeOf(typeof(IMAGE_DOS_HEADER))); if (array != null) { ushort num = BitConverter.ToUInt16(array, 0); uint num2 = BitConverter.ToUInt32(array, 60); if (num == 23117) { byte[] array2 = WinAPI.ReadRemoteMemory(hProcess, hModule.Add((long)((ulong)num2)), (uint)Marshal.SizeOf(typeof(IMAGE_NT_HEADER32))); if (array2 != null && BitConverter.ToUInt32(array2, 0) == 17744u) { IMAGE_NT_HEADER32 iMAGE_NT_HEADER = default(IMAGE_NT_HEADER32); using (UnmanagedBuffer unmanagedBuffer = new UnmanagedBuffer(256)) { if (unmanagedBuffer.Translate <IMAGE_NT_HEADER32>(array2, out iMAGE_NT_HEADER)) { return(iMAGE_NT_HEADER.OptionalHeader.AddressOfEntryPoint); } } return(0u); } } } return(0u); }
/** * Find the entry point of a loaded module * based on its Base Address. Reverses the PE * structure to find the entry point */ private static uint FindEntryPoint(IntPtr hProcess, IntPtr hModule) { if (hProcess.IsNull() || hProcess.Compare(-1)) { throw new ArgumentException("Invalid process handle.", "hProcess"); } if (hModule.IsNull()) { throw new ArgumentException("Invalid module handle.", "hModule"); } byte[] bDosHeader = WinAPI.ReadRemoteMemory(hProcess, hModule, (uint)Marshal.SizeOf(typeof(IMAGE_DOS_HEADER))); if (bDosHeader != null) { ushort e_magic = BitConverter.ToUInt16(bDosHeader, 0); uint e_lfanew = BitConverter.ToUInt32(bDosHeader, 0x3C); if (e_magic == 23117) { byte[] bNtHeader = WinAPI.ReadRemoteMemory(hProcess, hModule.Add(e_lfanew), (uint)Marshal.SizeOf(typeof(IMAGE_NT_HEADER32))); if (bNtHeader != null && BitConverter.ToUInt32(bNtHeader, 0) == 17744) { IMAGE_NT_HEADER32 ntHd = default(IMAGE_NT_HEADER32); using (var buffer = new UnmanagedBuffer(256)) if (buffer.Translate <IMAGE_NT_HEADER32>(bNtHeader, out ntHd)) { return(ntHd.OptionalHeader.AddressOfEntryPoint); } } } } return(0); }
private void btnDisAsm_Click(object sender, EventArgs e) { rtbHexDump.Clear(); //Console.WriteLine("Version: " + BeaEngine.Version); //Console.WriteLine("Revision: " + BeaEngine.Revision); //UnmanagedBuffer buffer = new UnmanagedBuffer(File.ReadAllBytes("BeaEngine.dll")); uint address = Convert.ToUInt32(tbOffsetToWatch.Text, 16); uint naddress = address + (uint)baseAddressModule; UnmanagedBuffer buffer = new UnmanagedBuffer(procTools.Memory.ReadBytes(naddress, 1120)); var disasm = new Disasm(); //disasm.EIP = new IntPtr(buffer.Ptr.ToInt64() + 0x400); disasm.EIP = new IntPtr(buffer.Ptr.ToInt64()); for (int counter = 0; counter < 100; ++counter) { int result = BeaEngine.Disasm(disasm); if (result == (int)BeaConstants.SpecialInfo.UNKNOWN_OPCODE) { break; } //rtbHexDump.AppendText("0x" + disasm.EIP.ToString("X") + " " + disasm.CompleteInstr+"\r\n"); rtbHexDump.AppendText("0x" + address.ToString("X") + "\t" + disasm.CompleteInstr + "\r\n"); disasm.EIP = new IntPtr(disasm.EIP.ToInt64() + result); address += (uint)result; } }
static void RunTest(string testTypeName, string throwExceptionStr) { bool throwExceptionInner = bool.Parse(throwExceptionStr); var buffer = UnmanagedBuffer <L8> .Allocate(100); var allocator = new MockUnmanagedMemoryAllocator <L8>(buffer); Configuration.Default.MemoryAllocator = allocator; var image = new Image <L8>(10, 10); Assert.Equal(1, UnmanagedMemoryHandle.TotalOutstandingHandles); try { GetTest(testTypeName).ProcessPixelRowsImpl(image, _ => { ((IDisposable)buffer).Dispose(); Assert.Equal(1, UnmanagedMemoryHandle.TotalOutstandingHandles); if (throwExceptionInner) { throw new NonFatalException(); } }); } catch (NonFatalException) { } Assert.Equal(0, UnmanagedMemoryHandle.TotalOutstandingHandles); }
internal static object MarshalFromUnmanaged(uint tomarshal, UnmanagedType type, uint sizeconst, Type knowntype) { if (type == UnmanagedType.Interface) { if (knowntype == typeof(UnmanagedBuffer)) { return((object)new UnmanagedBuffer((IntPtr)tomarshal)); } else { return(UnmanagedObject.Create(knowntype, (IntPtr)tomarshal)); } } else if (type == UnmanagedType.LPStruct) { UnmanagedBuffer buff = new UnmanagedBuffer((IntPtr)tomarshal); return(buff.ReadAt(0, knowntype)); } else if (type == UnmanagedType.LPWStr) { UnmanagedBuffer buff = new UnmanagedBuffer((IntPtr)tomarshal); return((object)buff.ReadUnicodeStringAt(0)); } else if (type == UnmanagedType.LPStr) { UnmanagedBuffer buff = new UnmanagedBuffer((IntPtr)tomarshal); return((object)buff.ReadStringAt(0)); } else { return((object)tomarshal); } }
public void RefCountedTest() { var sharedPool = new SharedPool <UnmanagedBuffer>(() => UnmanagedBuffer.Allocate(100), 1); var shared = sharedPool.GetOrCreate(); // refcount = 1 // a private copy shoudl point to the same resource var otherShared = shared.DeepClone(); // refcount = 1 + 1 Assert.AreNotEqual(shared, otherShared); Assert.AreEqual(shared.Inner, otherShared.Inner); Assert.AreEqual(shared.Resource, otherShared.Resource); // a clone should point to the same resource, but should not reuse the container var cloned = otherShared; Serializer.Clone(shared, ref cloned, new SerializationContext()); // refcount = 2 - 1 + 1 Assert.AreNotEqual(shared, cloned); Assert.AreEqual(shared.Inner, cloned.Inner); Assert.AreEqual(shared.Resource, cloned.Resource); // disposing should not affect other copies shared.Dispose(); // refcount = 2 - 1 Assert.AreEqual(0, sharedPool.AvailableCount); Assert.IsNull(shared.Inner); Assert.IsNull(shared.Resource); Assert.IsNotNull(cloned.Inner); Assert.IsNotNull(cloned.Resource); // disposing the last copy should return the resource to the pool cloned.Dispose(); // refcount = 1 - 1 Assert.AreEqual(1, sharedPool.AvailableCount); Assert.IsNull(cloned.Inner); Assert.IsNull(cloned.Resource); }
/// <inheritdoc /> internal override MemoryGroup <T> AllocateGroup <T>( long totalLength, int bufferAlignment, AllocationOptions options = AllocationOptions.None) { long totalLengthInBytes = totalLength * Unsafe.SizeOf <T>(); if (totalLengthInBytes <= this.sharedArrayPoolThresholdInBytes) { var buffer = new SharedArrayPoolBuffer <T>((int)totalLength); return(MemoryGroup <T> .CreateContiguous(buffer, options.Has(AllocationOptions.Clean))); } if (totalLengthInBytes <= this.poolBufferSizeInBytes) { // Optimized path renting single array from the pool UnmanagedMemoryHandle mem = this.pool.Rent(); if (mem.IsValid) { UnmanagedBuffer <T> buffer = this.pool.CreateGuardedBuffer <T>(mem, (int)totalLength, options.Has(AllocationOptions.Clean)); return(MemoryGroup <T> .CreateContiguous(buffer, options.Has(AllocationOptions.Clean))); } } // Attempt to rent the whole group from the pool, allocate a group of unmanaged buffers if the attempt fails: if (MemoryGroup <T> .TryAllocate(this.pool, totalLength, bufferAlignment, options, out MemoryGroup <T> poolGroup)) { return(poolGroup); } return(MemoryGroup <T> .Allocate(this.nonPoolAllocator, totalLength, bufferAlignment, options)); }
private void ThreadTest() { this.isRunning = true; var i2cController = I2cController.FromName(SC20260.I2cBus.I2c1); try { var ov9655 = new Ov9655Controller(i2cController); read_id: try { var id = ov9655.ReadId(); } catch { goto read_id; } byte[] data = null; UnmanagedBuffer unmangedBuffer = null; if (Memory.UnmanagedMemory.FreeBytes != 0) { unmangedBuffer = new UnmanagedBuffer(640 * 480 * 2); data = unmangedBuffer.Bytes; } else { data = new byte[640 * 480 * 2]; } ov9655.SetResolution(Ov9655Controller.Resolution.Vga); var displayController = Display.DisplayController; while (this.isRunning) { try { ov9655.Capture(data, 500); displayController.DrawBuffer(0, this.TopBar.ActualHeight, 0, 0, 480, 272 - this.TopBar.ActualHeight, 640, data, 0); } catch { } Thread.Sleep(10); } if (unmangedBuffer != null) { unmangedBuffer.Dispose(); } } catch { } this.isRunning = false; return; }
/// <inheritdoc /> public override IMemoryOwner <T> Allocate <T>( int length, AllocationOptions options = AllocationOptions.None) { Guard.MustBeGreaterThanOrEqualTo(length, 0, nameof(length)); int lengthInBytes = length * Unsafe.SizeOf <T>(); if (lengthInBytes <= this.sharedArrayPoolThresholdInBytes) { var buffer = new SharedArrayPoolBuffer <T>(length); if (options.Has(AllocationOptions.Clean)) { buffer.GetSpan().Clear(); } return(buffer); } if (lengthInBytes <= this.poolBufferSizeInBytes) { UnmanagedMemoryHandle mem = this.pool.Rent(); if (mem.IsValid) { UnmanagedBuffer <T> buffer = this.pool.CreateGuardedBuffer <T>(mem, length, options.Has(AllocationOptions.Clean)); return(buffer); } } return(this.nonPoolAllocator.Allocate <T>(length, options)); }
/// <summary> /// Create unmanaged image from the specified managed image. /// </summary> /// <param name="imageData">Source locked image data.</param> /// <returns>Returns new unmanaged image, which is a copy of source managed image.</returns> /// <remarks><para>The method creates an exact copy of specified managed image, but allocated /// in unmanaged memory. This means that managed image may be unlocked right after call to this /// method.</para></remarks> public static Image FromManagedImage(BitmapData imageData) { PixelFormat pixelFormat = PixelFormatHelper.FromSystemPixelFormat(imageData.PixelFormat); // allocate memory for the image return(new Image(UnmanagedBuffer.CreateCopyFrom(imageData.Scan0, imageData.Stride * imageData.Height), imageData.Width, imageData.Height, imageData.Stride, pixelFormat)); }
/// <summary> /// Disassembles the given code /// </summary> /// <param name="generatedCode">The generated code</param> public string Disassemble(IList <byte> generatedCode) { var output = new StringBuilder(); var buffer = new UnmanagedBuffer(generatedCode.ToArray()); var disasm = new Disasm() { Archi = 64 }; int offset = 0; while (offset < generatedCode.Count) { disasm.EIP = new IntPtr(buffer.Ptr.ToInt64() + offset); int result = BeaEngine64.Disasm(disasm); if (result == (int)BeaConstants.SpecialInfo.UNKNOWN_OPCODE) { break; } //strBuffer.AppendLine("0x" + offset.ToString("X") + " " + disasm.CompleteInstr); output.AppendLine(disasm.CompleteInstr); offset += result; } return(output.ToString()); }
// ----------------------------- // ---- PAL layer ends here ---- // ----------------------------- private void EnsureCapacity(int capacity) { // Make sure the requested capacity doesn't exceed SecureString's defined limit if (capacity > MaxLength) { throw new ArgumentOutOfRangeException(nameof(capacity), SR.ArgumentOutOfRange_Capacity); } // If we already have enough space allocated, we're done if (_buffer != null && (capacity * sizeof(char)) <= (int)_buffer.ByteLength) { return; } // We need more space, so allocate a new buffer, copy all our data into it, // and then swap the new for the old. UnmanagedBuffer newBuffer = UnmanagedBuffer.Allocate(capacity * sizeof(char)); if (_buffer != null) { UnmanagedBuffer.Copy(_buffer, newBuffer, _buffer.ByteLength); _buffer.Dispose(); } _buffer = newBuffer; }
private static uint FindEntryPoint(IntPtr hProcess, IntPtr hModule) { if (hProcess.IsNull() || hProcess.Compare(-1L)) { throw new ArgumentException("Invalid process handle.", "hProcess"); } if (hModule.IsNull()) { throw new ArgumentException("Invalid module handle.", "hModule"); } byte[] buffer = WinAPI.ReadRemoteMemory(hProcess, hModule, (uint)Marshal.SizeOf(typeof(IMAGE_DOS_HEADER))); if (buffer != null) { ushort num = BitConverter.ToUInt16(buffer, 0); uint num2 = BitConverter.ToUInt32(buffer, 60); if (num == 0x5a4d) { byte[] buffer2 = WinAPI.ReadRemoteMemory(hProcess, hModule.Add((long)num2), (uint)Marshal.SizeOf(typeof(IMAGE_NT_HEADER32))); if ((buffer2 != null) && (BitConverter.ToUInt32(buffer2, 0) == 0x4550)) { IMAGE_NT_HEADER32 result = new IMAGE_NT_HEADER32(); using (UnmanagedBuffer buffer3 = new UnmanagedBuffer(0x100)) { if (buffer3.Translate <IMAGE_NT_HEADER32>(buffer2, out result)) { return(result.OptionalHeader.AddressOfEntryPoint); } } } } } return(0); }
internal static unsafe void Copy(UnmanagedBuffer source, UnmanagedBuffer destination, ulong bytesLength) { if (bytesLength == 0) { return; } byte *srcPtr = null, dstPtr = null; try { source.AcquirePointer(ref srcPtr); destination.AcquirePointer(ref dstPtr); Buffer.MemoryCopy(srcPtr, dstPtr, destination.ByteLength, bytesLength); } finally { if (dstPtr != null) { destination.ReleasePointer(); } if (srcPtr != null) { source.ReleasePointer(); } } }
/// <summary> /// Disassembles the given code /// </summary> /// <param name="generatedCode">The generated code</param> public static string Disassemble(IList<byte> generatedCode) { var strBuffer = new StringBuilder(); var buffer = new UnmanagedBuffer(generatedCode.ToArray()); var disasm = new Disasm(); disasm.Archi = 64; int offset = 0; while (offset < generatedCode.Count) { disasm.EIP = new IntPtr(buffer.Ptr.ToInt64() + offset); int result = BeaEngine64.Disasm(disasm); if (result == (int)BeaConstants.SpecialInfo.UNKNOWN_OPCODE) { break; } //strBuffer.AppendLine("0x" + offset.ToString("X") + " " + disasm.CompleteInstr); strBuffer.AppendLine(disasm.CompleteInstr); offset += result; } return strBuffer.ToString(); }
public static T ReadEnumAttribute <T>(hid_t hid, string key) where T : struct, IConvertible { var attribute = H5A.open(hid, key); if (attribute < 0) { throw new ArgumentException(string.Format("Attribute {0} not found.", key)); } var type = H5A.get_type(attribute); if (type < 0) { H5A.close(attribute); throw new Exception("H5A.get_type failed."); } var size = H5T.get_size(type).ToInt32(); if (size == 0) { H5T.close(type); H5A.close(attribute); throw new Exception("H5T.get_size failed."); } var unmanagedBuffer = new UnmanagedBuffer(size); H5A.read(attribute, type, unmanagedBuffer); H5T.close(type); H5A.close(attribute); return(unmanagedBuffer.ReadEnum <T>()); }
//static constructor: inject code required to perform the call once static UnmanagedCall() { uint loopaddress; uint code_alignment; uint pAddress; uint pStacksize; uint ppStack; uint pThisPar; uint pRetVal; uint pStackPointerBackup; AsmBuilder asm = new AsmBuilder(); //should use our own heap, not the default heap; since the code buffer needs execution rights m_Parameters = Allocator.AllocateBuffer(7 * 4); m_Code = Allocator.AllocateBuffer(61); data_alignment = ((uint)m_Parameters.Address) % 4; code_alignment = ((uint)m_Code.Address) % 4; pAddress = (uint)m_Parameters.Address + data_alignment + 4 * 0; pStacksize = (uint)m_Parameters.Address + data_alignment + 4 * 1; ppStack = (uint)m_Parameters.Address + data_alignment + 4 * 2; pThisPar = (uint)m_Parameters.Address + data_alignment + 4 * 3; pRetVal = (uint)m_Parameters.Address + data_alignment + 4 * 4; pStackPointerBackup = (uint)m_Parameters.Address + data_alignment + 4 * 5; //backup context asm.Instructions.Add(new PushAll()); asm.Instructions.Add(new BackupEsp(pStackPointerBackup)); //build stack asm.Instructions.Add(new MovEcxMemory(pStacksize)); asm.Instructions.Add(new MovEdxMemory(ppStack)); //store current position for the stack push loop loopaddress = code_alignment + (uint)asm.Size; //relative //build stack builder loop asm.Instructions.Add(new MovEaxEdx()); asm.Instructions.Add(new DereferEax()); asm.Instructions.Add(new PushEax()); asm.Instructions.Add(new AddEdx(4)); asm.Instructions.Add(new DecEcx()); asm.Instructions.Add(new JnzRelativeShort((int)loopaddress)); //build call asm.Instructions.Add(new MovEcxMemory(pThisPar)); asm.Instructions.Add(new CallFunctionPointer(pAddress)); //store return value asm.Instructions.Add(new MovMemoryEax(pRetVal)); //restore context asm.Instructions.Add(new RestoreEsp(pStackPointerBackup)); asm.Instructions.Add(new PopAll()); //return asm.Instructions.Add(new Rtn()); //write code asm.Write(m_Code, (int)code_alignment); //build function pointer m_Call = (SimpleCallDelegate)Marshal.GetDelegateForFunctionPointer((IntPtr)((uint)m_Code.Address + code_alignment), typeof(SimpleCallDelegate)); }
/// <summary> /// Initializes a new instance of the <see cref="Image"/> class. /// </summary> /// <param name="imageData">Pointer to image data in unmanaged memory.</param> /// <param name="width">Image width in pixels.</param> /// <param name="height">Image height in pixels.</param> /// <param name="stride">Image stride (line size in bytes).</param> /// <param name="pixelFormat">Image pixel format.</param> /// <remarks><para><note>Using this constructor, make sure all specified image attributes are correct /// and correspond to unmanaged memory buffer. If some attributes are specified incorrectly, /// this may lead to exceptions working with the unmanaged memory.</note></para></remarks> public Image(IntPtr imageData, int width, int height, int stride, PixelFormat pixelFormat) { this.image = UnmanagedBuffer.WrapIntPtr(imageData, height * stride); this.width = width; this.height = height; this.stride = stride; this.pixelFormat = pixelFormat; }
/// <summary> /// Initializes a new instance of the <see cref="Image"/> class. /// </summary> /// <param name="image">The unmanaged array containing the image.</param> /// <param name="width">Image width in pixels.</param> /// <param name="height">Image height in pixels.</param> /// <param name="stride">Image stride (line size in bytes).</param> /// <param name="pixelFormat">Image pixel format.</param> /// <remarks><para><note>Using this constructor, make sure all specified image attributes are correct /// and correspond to unmanaged memory buffer. If some attributes are specified incorrectly, /// this may lead to exceptions working with the unmanaged memory.</note></para></remarks> public Image(UnmanagedBuffer image, int width, int height, int stride, PixelFormat pixelFormat) { this.image = image; this.width = width; this.height = height; this.stride = stride; this.pixelFormat = pixelFormat; }
public void CopyToValidation3() { using (UnmanagedBuffer source = GetBuffer(BUFFER_SIZE, false), target = GetBuffer(BUFFER_SIZE, false)) { source.CopyTo(target); } }
private void DisposeCore() { if (_buffer != null && !_buffer.IsInvalid) { _buffer.Dispose(); _buffer = null; } }
/// <summary> /// Initializes a new instance of the <see cref="Image"/> class. /// </summary> /// <param name="bitmapData">Locked bitmap data.</param> /// <remarks><note>Unlike <see cref="FromManagedImage(BitmapData)"/> method, this constructor does not make /// copy of managed image. This means that managed image must stay locked for the time of using the instance /// of unamanged image.</note></remarks> public Image(BitmapData bitmapData) { this.image = UnmanagedBuffer.WrapIntPtr(bitmapData.Scan0, bitmapData.Height * bitmapData.Stride); this.width = bitmapData.Width; this.height = bitmapData.Height; this.stride = bitmapData.Stride; this.pixelFormat = PixelFormatHelper.FromSystemPixelFormat(bitmapData.PixelFormat); }
public void CopyValidateSize3() { using (UnmanagedBuffer source = GetBuffer(BUFFER_SIZE, true), target = GetBuffer(BUFFER_SIZE, true)) { source.CopyTo(target, BUFFER_SIZE * 2); } }
/// <summary> /// Creates a new disassembler /// </summary> /// <param name="compilationData">The compilation data</param> public Disassembler(AbstractCompilationData compilationData) { this.compilationData = compilationData; this.codeBuffer = new UnmanagedBuffer(compilationData.Function.GeneratedCode.ToArray()); this.disassembler = new Disasm(); this.disassembler.Archi = 64; this.disassembler.EIP = new IntPtr(this.codeBuffer.Ptr.ToInt64()); }
internal static UnmanagedBuffer Allocate(int bytes) { Debug.Assert(bytes >= 0); UnmanagedBuffer buffer = new UnmanagedBuffer(); buffer.SetHandle(Marshal.AllocHGlobal(bytes)); buffer.Initialize((ulong)bytes); return(buffer); }
/// <summary> /// Initializes a new instance of the <see cref="ImageBase"/> class. /// </summary> /// <param name="bitmapData">Locked bitmap data.</param> /// <param name="makeCopy">Indicates whether a copy is made (default is false).</param> /// <remarks> /// <para>When the <paramref name="makeCopy"/> parameter is false (default), the image simply wraps /// the bitmap data. As such, the bitmap data must stay locked for the duration of using the <see cref="ImageBase"/> object. /// </para> /// <para>If the <paramref name="makeCopy"/> parameter is set to true, a copy of the bitmap /// data is made, and the bitmap data can be released right after the <see cref="ImageBase"/> has been constructed. /// </para> /// </remarks> public ImageBase(BitmapData bitmapData, bool makeCopy = false) { this.image = makeCopy ? UnmanagedBuffer.CreateCopyFrom(bitmapData.Scan0, bitmapData.Stride * bitmapData.Height) : UnmanagedBuffer.WrapIntPtr(bitmapData.Scan0, bitmapData.Height * bitmapData.Stride); this.width = bitmapData.Width; this.height = bitmapData.Height; this.stride = bitmapData.Stride; this.pixelFormat = PixelFormatHelper.FromSystemPixelFormat(bitmapData.PixelFormat); }
#pragma warning restore CA1419 public static UnmanagedBuffer Allocate(int byteLength) { Debug.Assert(byteLength >= 0); UnmanagedBuffer buffer = new UnmanagedBuffer(); buffer.SetHandle(Marshal.AllocHGlobal(byteLength)); buffer.Initialize((ulong)byteLength); buffer._byteLength = byteLength; return(buffer); }
public void Allocate_CreatesValidBuffer() { using var buffer = UnmanagedBuffer <int> .Allocate(10); Span <int> span = buffer.GetSpan(); Assert.Equal(10, span.Length); span[9] = 123; Assert.Equal(123, span[9]); }
/// <summary> /// Creates a new disassembler /// </summary> /// <param name="compilationData">The compilation data</param> public Disassembler(AbstractCompilationData compilationData) { this.compilationData = compilationData; this.codeBuffer = new UnmanagedBuffer(compilationData.Function.GeneratedCode.ToArray()); this.disassembler = new Disasm() { Archi = 64, EIP = new IntPtr(this.codeBuffer.Ptr.ToInt64()) }; }
private Geobase(UnmanagedBuffer buffer) { _buffer = buffer; var cityIndexData = GeobaseIndexData <GLocation> .Create(Header.Records, GetCityLocationIndex, GetLocation); CityIndex = new GeobaseIndex <string, GLocation>(cityIndexData, new GCityComparer()); var ipIntervalIndexData = GeobaseIndexData <GIpInterval> .Create(Header.Records, idx => idx, GetIpInterval); IpIntervalIndex = new GeobaseIndex <string, GIpInterval>(ipIntervalIndexData, new GIpComparer()); }
internal SecureString(SecureString str) { // Allocate enough space to store the provided string EnsureCapacity(str._decryptedLength); _decryptedLength = str._decryptedLength; // Copy the string into the newly allocated space if (_decryptedLength > 0) { UnmanagedBuffer.Copy(str._buffer, _buffer, (ulong)(str._decryptedLength * sizeof(char))); } }
private SecureString(SecureString str) { Debug.Assert(str._buffer != null, "Expected other SecureString's buffer to be non-null"); Debug.Assert(str._encrypted, "Expected to be used only on encrypted SecureStrings"); _buffer = UnmanagedBuffer.Allocate((int)str._buffer.ByteLength); Debug.Assert(_buffer != null); UnmanagedBuffer.Copy(str._buffer, _buffer, str._buffer.ByteLength); _decryptedLength = str._decryptedLength; _encrypted = str._encrypted; }
internal SmtpSession(TcpClient client, UnmanagedBuffer buffer) { m_client = client; m_buffer = buffer; }
private unsafe void ReadFileIntoUnmanagedBuffer(System.IO.FileStream/*!*/ inputStream) { long size = inputStream.Seek(0, System.IO.SeekOrigin.End); if (size > int.MaxValue) throw new System.IO.FileLoadException(); inputStream.Seek(0, System.IO.SeekOrigin.Begin); int n = (int)size; this.bufferLength = n; this.unmanagedBuffer = new UnmanagedBuffer(n); byte* pb = (byte*)this.unmanagedBuffer.Pointer; #if !ROTOR #if WHIDBEY && !OldWhidbey if (!Reader.ReadFile(inputStream.SafeFileHandle.DangerousGetHandle(), pb, n, &n, IntPtr.Zero)) throw new System.IO.FileLoadException(); #else if (!Reader.ReadFile(inputStream.Handle, pb, n, &n, IntPtr.Zero)) throw new System.IO.FileLoadException(); #endif #else //Read a fixed length block at a time, so that the GC does not come under pressure from lots of large byte arrays. int bufferLen = 8096; byte[] buffer = new byte[bufferLen]; while (n > 0){ if (n < bufferLen) bufferLen = n; inputStream.Read(buffer, 0, bufferLen); for (int i = 0; i < bufferLen; i++) *pb++ = buffer[i]; n -= bufferLen; } #endif }
public void Dispose(){ if (this.unmanagedBuffer != null) this.unmanagedBuffer.Dispose(); this.unmanagedBuffer = null; if (this.tables != null) this.tables.Dispose(); //this.tables = null; #if !ROTOR && !UseSingularityPDB if (this.debugReader != null) Marshal.ReleaseComObject(this.debugReader); this.debugReader = null; #endif }
internal unsafe Reader(byte[]/*!*/ buffer, IDictionary localAssemblyCache, bool doNotLockFile, bool getDebugInfo, bool useStaticCache, bool preserveShortBranches) { Debug.Assert(buffer != null); if (localAssemblyCache == null) localAssemblyCache = new Hashtable(); this.localAssemblyCache = localAssemblyCache; this.getDebugSymbols = getDebugInfo; this.doNotLockFile = false; this.useStaticCache = useStaticCache; this.preserveShortBranches = preserveShortBranches; int n = this.bufferLength = buffer.Length; this.unmanagedBuffer = new UnmanagedBuffer(n); //^ base(); byte* pb = (byte*)this.unmanagedBuffer.Pointer; for (int i = 0; i < n; i++) *pb++ = buffer[i]; }
internal static UnmanagedBuffer Allocate(int bytes) { Debug.Assert(bytes >= 0); UnmanagedBuffer buffer = new UnmanagedBuffer(); buffer.SetHandle(Marshal.AllocHGlobal(bytes)); buffer.Initialize((ulong)bytes); return buffer; }
internal static unsafe void Copy(UnmanagedBuffer source, UnmanagedBuffer destination, ulong bytesLength) { if (bytesLength == 0) { return; } byte* srcPtr = null, dstPtr = null; try { source.AcquirePointer(ref srcPtr); destination.AcquirePointer(ref dstPtr); Buffer.MemoryCopy(srcPtr, dstPtr, destination.ByteLength, bytesLength); } finally { if (dstPtr != null) { destination.ReleasePointer(); } if (srcPtr != null) { source.ReleasePointer(); } } }
/** * Find the entry point of a loaded module * based on its Base Address. Reverses the PE * structure to find the entry point */ private static uint FindEntryPoint(IntPtr hProcess, IntPtr hModule) { if (hProcess.IsNull() || hProcess.Compare(-1)) throw new ArgumentException("Invalid process handle.", "hProcess"); if (hModule.IsNull()) throw new ArgumentException("Invalid module handle.", "hModule"); byte[] bDosHeader = WinAPI.ReadRemoteMemory(hProcess, hModule, (uint)Marshal.SizeOf(typeof(IMAGE_DOS_HEADER))); if (bDosHeader != null) { ushort e_magic = BitConverter.ToUInt16(bDosHeader, 0); uint e_lfanew = BitConverter.ToUInt32(bDosHeader, 0x3C); if (e_magic == 23117) { byte[] bNtHeader = WinAPI.ReadRemoteMemory(hProcess, hModule.Add(e_lfanew), (uint)Marshal.SizeOf(typeof(IMAGE_NT_HEADER32))); if (bNtHeader != null && BitConverter.ToUInt32(bNtHeader, 0) == 17744) { IMAGE_NT_HEADER32 ntHd = default(IMAGE_NT_HEADER32); using (var buffer = new UnmanagedBuffer(256)) if (buffer.Translate<IMAGE_NT_HEADER32>(bNtHeader, out ntHd)) return ntHd.OptionalHeader.AddressOfEntryPoint; } } } return 0; }
public void Add(UnmanagedBuffer buffer) { m_pool.Add(buffer); }