ReLibreHardwareMonitor/LibreHardwareMonitorLib/Hardware/InpOut.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using LibreHardwareMonitor.Interop;

namespace LibreHardwareMonitor.Hardware
{
    internal static class InpOut
    {
        private static string _filePath;
        private static IntPtr _libraryHandle;
        private static Interop.InpOut.MapPhysToLinDelegate _mapPhysToLin;
        private static Interop.InpOut.UnmapPhysicalMemoryDelegate _unmapPhysicalMemory;

        public static bool IsOpen { get; private set; }

        public static bool Open()
        {
            if (Software.OperatingSystem.IsUnix)
                return false;

            if (IsOpen)
                return true;

            _filePath = GetFilePath();
            if (_filePath != null && (File.Exists(_filePath) || Extract(_filePath)))
            {
                _libraryHandle = Kernel32.LoadLibrary(_filePath);
                if (_libraryHandle != IntPtr.Zero)
                {
                    IntPtr mapPhysToLinAddress = Kernel32.GetProcAddress(_libraryHandle, "MapPhysToLin");
                    IntPtr unmapPhysicalMemoryAddress = Kernel32.GetProcAddress(_libraryHandle, "UnmapPhysicalMemory");

                    if (mapPhysToLinAddress != IntPtr.Zero)
                        _mapPhysToLin = Marshal.GetDelegateForFunctionPointer<Interop.InpOut.MapPhysToLinDelegate>(mapPhysToLinAddress);

                    if (unmapPhysicalMemoryAddress != IntPtr.Zero)
                        _unmapPhysicalMemory = Marshal.GetDelegateForFunctionPointer<Interop.InpOut.UnmapPhysicalMemoryDelegate>(unmapPhysicalMemoryAddress);

                    IsOpen = true;
                }
            }

            if (!IsOpen)
                DeleteDll();

            return IsOpen;
        }

        public static void Close()
        {
            if (_libraryHandle != IntPtr.Zero)
            {
                Kernel32.FreeLibrary(_libraryHandle);
                DeleteDll();

                _libraryHandle = IntPtr.Zero;
            }

            IsOpen = false;
        }

        public static byte[] ReadMemory(IntPtr baseAddress, uint size)
        {
            if (_mapPhysToLin != null && _unmapPhysicalMemory != null)
            {
                IntPtr pdwLinAddr = _mapPhysToLin(baseAddress, size, out IntPtr pPhysicalMemoryHandle);
                if (pdwLinAddr != IntPtr.Zero)
                {
                    byte[] bytes = new byte[size];
                    Marshal.Copy(pdwLinAddr, bytes, 0, bytes.Length);
                    _unmapPhysicalMemory(pPhysicalMemoryHandle, pdwLinAddr);

                    return bytes;
                }
            }

            return null;
        }

        private static void DeleteDll()
        {
            try
            {
                // try to delete the DLL
                if (_filePath != null && File.Exists(_filePath))
                {
                    File.Delete(_filePath);
                }

                _filePath = null;
            }
            catch
            { }
        }

        private static string GetFilePath()
        {
            string filePath;

            try
            {
                filePath = Path.GetTempFileName();
                if (!string.IsNullOrEmpty(filePath))
                    return Path.ChangeExtension(filePath, ".dll");
            }
            catch (IOException)
            { }

            const string fileName = "inpout.dll";

            try
            {
                ProcessModule processModule = Process.GetCurrentProcess().MainModule;
                if (!string.IsNullOrEmpty(processModule?.FileName))
                    return Path.Combine(Path.GetDirectoryName(processModule.FileName) ?? string.Empty, fileName);
            }
            catch
            {
                // Continue with the other options.
            }

            filePath = GetPathFromAssembly(Assembly.GetExecutingAssembly());
            if (!string.IsNullOrEmpty(filePath))
                return Path.Combine(Path.GetDirectoryName(filePath) ?? string.Empty, fileName);

            filePath = GetPathFromAssembly(typeof(Ring0).Assembly);
            if (!string.IsNullOrEmpty(filePath))
                return Path.Combine(Path.GetDirectoryName(filePath) ?? string.Empty, fileName);

            return null;

            static string GetPathFromAssembly(Assembly assembly)
            {
                try
                {
                    string location = assembly?.Location;
                    return !string.IsNullOrEmpty(location) ? location : null;
                }
                catch
                {
                    return null;
                }
            }
        }

        private static bool Extract(string filePath)
        {
            string resourceName = $"{nameof(LibreHardwareMonitor)}.Resources.{(Software.OperatingSystem.Is64Bit ? "inpoutx64.dll" : "inpout32.dll")}";

            Assembly assembly = typeof(Ring0).Assembly;

            string[] names = assembly.GetManifestResourceNames();
            byte[] buffer = null;

            for (int i = 0; i < names.Length; i++)
            {
                if (names[i].Replace('\\', '.') == resourceName)
                {
                    using Stream stream = assembly.GetManifestResourceStream(names[i]);

                    if (stream != null)
                    {
                        buffer = new byte[stream.Length];
                        stream.Read(buffer, 0, buffer.Length);
                    }
                }
            }

            if (buffer == null)
                return false;

            try
            {
                using FileStream target = new(filePath, FileMode.Create);

                target.Write(buffer, 0, buffer.Length);
                target.Flush();
            }
            catch
            {
                // for example there is not enough space on the disk
                return false;
            }

            // make sure the file is actually written to the file system
            var stopwatch = new Stopwatch();
            stopwatch.Start();

            while (stopwatch.ElapsedMilliseconds < 2000)
            {
                try
                {
                    if (File.Exists(filePath) && new FileInfo(filePath).Length == buffer.Length)
                        return true;
                }
                catch
                { }

                Thread.Sleep(1);
            }

            // file still has not the right size, something is wrong
            return false;
        }
    }
}