fork/m-overlay

git clone https://git.julia.blue/fork/m-overlay

BkacjiosBugfixes + Dark Mode skina8034e9

v2.1.1b
9.5 KiB375 linesraw
1local ffi = require("ffi")
2local log = require("log")
3
4local format = string.format
5local tohex = string.tohex
6
7local cast = ffi.cast
8local cdef = ffi.cdef
9local load = ffi.load
10local metatype = ffi.metatype
11local new = ffi.new
12local typeof = ffi.typeof
13local sizeof = ffi.sizeof
14local string = ffi.string
15
16local lshift = bit.lshift
17local rshift = bit.rshift
18local bswap = bit.bswap
19local band = bit.band
20local bor = bit.bor
21
22local kernel = load("Kernel32.dll")
23local psapi = load("Psapi.dll")
24
25local libc = ffi.C
26
27cdef [[
28// Stupid Windows typenames..
29
30//#define MAX_PATH 260
31
32typedef int BOOL;
33typedef unsigned long DWORD;
34typedef long LONG;
35
36typedef void *PVOID;
37typedef PVOID HANDLE;
38
39typedef void *LPVOID;
40typedef const void *LPCVOID;
41
42typedef DWORD *LPDWORD;
43
44typedef char CHAR;
45
46typedef unsigned __int64 ULONG_PTR; // 64-bit
47// typedef unsigned long ULONG_PTR; // 32-bit
48
49typedef ULONG_PTR SIZE_T;
50
51typedef struct {
52	HANDLE process_handle;
53	ULONG_PTR dolphin_base_addr;
54	ULONG_PTR dolphin_addr_size;
55} MEMORY_STRUCT;
56
57typedef struct tagPROCESSENTRY32 {
58	DWORD dwSize;
59	DWORD cntUsage;
60	DWORD th32ProcessID;
61	ULONG_PTR th32DefaultHeapID; // DWORD on 32-bit
62	DWORD th32ModuleID;
63	DWORD cntThreads;
64	DWORD th32ParentProcessID;
65	LONG pcPriClassBase;
66	DWORD dwFlags;
67	CHAR  szExeFile[260];
68} PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
69
70HANDLE CreateToolhelp32Snapshot(
71	DWORD dwFlags,
72	DWORD th32ProcessID
73);
74
75BOOL Process32First(
76	HANDLE           hSnapshot,
77	LPPROCESSENTRY32 lppe
78);
79
80BOOL Process32Next(
81	HANDLE           hSnapshot,
82	LPPROCESSENTRY32 lppe
83);
84
85HANDLE OpenProcess(
86	DWORD dwDesiredAccess,
87	BOOL  bInheritHandle,
88	DWORD dwProcessId
89);
90
91BOOL ReadProcessMemory(
92	HANDLE  hProcess,
93	LPCVOID lpBaseAddress,
94	LPVOID  lpBuffer,
95	SIZE_T  nSize,
96	SIZE_T  *lpNumberOfBytesRead
97);
98
99BOOL WriteProcessMemory(
100	HANDLE  hProcess,
101	LPVOID  lpBaseAddress,
102	LPCVOID lpBuffer,
103	SIZE_T  nSize,
104	SIZE_T  *lpNumberOfBytesWritten
105);
106
107BOOL CloseHandle(
108	HANDLE hObject
109);
110
111typedef struct _MEMORY_BASIC_INFORMATION {
112	PVOID  BaseAddress;
113	PVOID  AllocationBase;
114	DWORD  AllocationProtect;
115	SIZE_T RegionSize;
116	DWORD  State;
117	DWORD  Protect;
118	DWORD  Type;
119} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
120
121typedef union _PSAPI_WORKING_SET_EX_BLOCK {
122	ULONG_PTR Flags;
123	/*union {
124		struct {
125			ULONG_PTR Valid : 1;
126			ULONG_PTR ShareCount : 3;
127			ULONG_PTR Win32Protection : 11;
128			ULONG_PTR Shared : 1;
129			ULONG_PTR Node : 6;
130			ULONG_PTR Locked : 1;
131			ULONG_PTR LargePage : 1;
132			ULONG_PTR Reserved : 7;
133			ULONG_PTR Bad : 1;
134			ULONG_PTR ReservedUlong : 32;
135		};
136		struct {
137			ULONG_PTR Valid : 1;
138			ULONG_PTR Reserved0 : 14;
139			ULONG_PTR Shared : 1;
140			ULONG_PTR Reserved1 : 15;
141			ULONG_PTR Bad : 1;
142			ULONG_PTR ReservedUlong : 32;
143		} Invalid;
144	};*/
145} PSAPI_WORKING_SET_EX_BLOCK, *PPSAPI_WORKING_SET_EX_BLOCK;
146
147typedef struct _PSAPI_WORKING_SET_EX_INFORMATION {
148	PVOID                      VirtualAddress;
149	PSAPI_WORKING_SET_EX_BLOCK VirtualAttributes;
150} PSAPI_WORKING_SET_EX_INFORMATION, *PPSAPI_WORKING_SET_EX_INFORMATION;
151
152SIZE_T VirtualQueryEx(
153	HANDLE                    hProcess,
154	LPCVOID                   lpAddress,
155	PMEMORY_BASIC_INFORMATION lpBuffer,
156	SIZE_T                    dwLength
157);
158
159BOOL QueryWorkingSetEx(
160	HANDLE hProcess,
161	PVOID  pv,
162	DWORD  cb
163);
164
165BOOL GetExitCodeProcess(
166	HANDLE  hProcess,
167	LPDWORD lpExitCode
168);
169
170DWORD WaitForSingleObject(
171	HANDLE hHandle,
172	DWORD  dwMilliseconds
173);
174
175DWORD GetLastError();
176]]
177
178local MEMORY = {}
179MEMORY.__index = MEMORY
180MEMORY.init = metatype("MEMORY_STRUCT", MEMORY)
181
182local TH32CS_SNAPPROCESS = 0x02
183
184local PROCESS_QUERY_INFORMATION = 0x0400
185local PROCESS_VM_OPERATION = 0x0008
186local PROCESS_VM_READ = 0x0010
187local PROCESS_VM_WRITE = 0x0020
188
189local MEM_MAPPED = 0x40000
190
191local STILL_ACTIVE = 259
192
193local function NOTWITHINMEMRANGE(addr)
194	return addr < 0x80000000 or addr > 0x81800000
195end
196
197local PROCESSENTRY32_PTR = typeof("PROCESSENTRY32[1]")
198local MEMORY_BASIC_INFORMATION_PTR = typeof("MEMORY_BASIC_INFORMATION[1]")
199local PSAPI_WORKING_SET_EX_INFORMATION_PTR = typeof("PSAPI_WORKING_SET_EX_INFORMATION[1]")
200
201function MEMORY:hasPermissions()
202	-- Windows doesn't need any special permissions to read memory from another process
203	return true
204end
205
206local valid_process_names = {
207	["Dolphin.exe"] = true,
208	["Slippi Dolphin.exe"] = true,
209	["DolphinWx.exe"] = true,
210	["DolphinQt2.exe"] = true,
211}
212
213do
214	local status = new("DWORD[1]")
215
216	function MEMORY:findprocess()
217		if self:hasProcess() then return false end
218
219		local handle
220		local snapshot = kernel.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) -- Create the snapshot
221
222		local pe32 = PROCESSENTRY32_PTR()[0] -- Will store the info about the process
223		pe32.dwSize = sizeof(pe32)
224
225		repeat
226			local name = string(pe32.szExeFile)
227			if valid_process_names[name] then
228				local handle = kernel.OpenProcess(PROCESS_VM_OPERATION + PROCESS_VM_READ + PROCESS_QUERY_INFORMATION, false, pe32.th32ProcessID)
229
230				-- Check if the process is active, we don't want to rehook the closing application
231				if handle ~= nil and kernel.GetExitCodeProcess(handle, status) and status[0] == STILL_ACTIVE then
232					-- We have an active process that matches, let's use it
233					self.process_handle = handle
234					break
235				elseif handle then
236					-- Dolphin is closing.. ignore and close the handle..
237					kernel.CloseHandle(handle)
238				end
239			end
240		until kernel.Process32Next(snapshot, pe32) == 0
241		
242		kernel.CloseHandle(snapshot)
243
244		return self:hasProcess()
245	end
246end
247
248do
249	local status = new("DWORD[1]")
250	
251	function MEMORY:isProcessActive()
252		return self.process_handle ~= nil and kernel.GetExitCodeProcess(self.process_handle, status) and status[0] == STILL_ACTIVE
253	end
254end
255
256function MEMORY:hasProcess()
257	return self.process_handle ~= nil
258end
259
260function MEMORY:clearGamecubeRAMOffset()
261	self.dolphin_base_addr = nil
262end
263
264function MEMORY:hasGamecubeRAMOffset()
265	return self.dolphin_base_addr ~= nil
266end
267
268function MEMORY:getGamecubeRAMOffset()
269	return tonumber(self.dolphin_base_addr)
270end
271
272function MEMORY:getGamecubeRAMSize()
273	return tonumber(self.dolphin_addr_size)
274end
275
276function MEMORY:close()
277	if self:hasProcess() then
278		kernel.CloseHandle(self.process_handle)
279		self.process_handle = nil
280		self.dolphin_base_addr = nil
281	end
282end
283
284function MEMORY:__gc()
285	self:close()
286end
287
288local regionptr = new("ULONG_PTR*[1]")
289
290local NULL = cast("ULONG_PTR", 0x00000000)
291local GC_RAM_SIZE = cast("ULONG_PTR", 0x2000000)
292
293function MEMORY:findGamecubeRAMOffset()
294	local info = MEMORY_BASIC_INFORMATION_PTR()[0]
295
296	local address = regionptr[0]
297
298	-- Scan all virtual address spaces the process is using.
299	while kernel.VirtualQueryEx(self.process_handle, address, info, sizeof(info)) == sizeof(info) do
300		address = address + info.RegionSize / sizeof(info.RegionSize)
301
302		-- Dolphin stores the GameCube RAM address space in 32MB chunks.
303		-- Extended memory override can allow up to 64MB.
304		if (info.RegionSize >= GC_RAM_SIZE and info.RegionSize % GC_RAM_SIZE == 0 and info.Type == MEM_MAPPED) then
305			local wsinfo = PSAPI_WORKING_SET_EX_INFORMATION_PTR()[0]
306			wsinfo.VirtualAddress = info.BaseAddress
307
308			-- Retrieve extended information about the virtual address space
309			if psapi.QueryWorkingSetEx(self.process_handle, wsinfo, sizeof(wsinfo)) == 1 then
310				local flags = tonumber(wsinfo.VirtualAttributes.Flags)
311
312				local base = cast("ULONG_PTR", info.BaseAddress)
313				local region = cast("ULONG_PTR", info.RegionSize)
314
315				-- Check that the VirtualAttributes flags contains VALID and the base address is not null
316				if band(flags, lshift(1, 0)) == 1 and cast("ULONG_PTR", info.BaseAddress) ~= NULL then
317					--log.debug("%08X %x", tonumber(base), tonumber(region))
318					self.dolphin_base_addr = base
319					self.dolphin_addr_size = region
320					return true
321				end
322			end
323		end
324	end
325
326	return false
327end
328
329local GC_RAM_START = cast("uint32_t", 0x80000000)
330local GC_RAM_END = cast("uint32_t", 0x81800000)
331local WII_RAM_START = cast("uint32_t", 0x90000000)
332local WII_RAM_END = cast("uint32_t", 0x94000000)
333
334local WII_RAM_LOCAL_START = cast("uint32_t", 0x02000000)
335
336local CAST_ADDR = ffi.new("uint32_t", 0x00000000)
337local memread = ffi.new("SIZE_T[1]") -- How many bytes are read from memory
338
339function MEMORY:read(addr, output, size)
340	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
341
342	CAST_ADDR = cast("uint32_t", addr)
343
344	if CAST_ADDR >= WII_RAM_START and CAST_ADDR <= WII_RAM_END then
345		CAST_ADDR = cast("uint32_t", WII_RAM_LOCAL_START + (CAST_ADDR % WII_RAM_START))
346	elseif CAST_ADDR >= GC_RAM_START and CAST_ADDR <= GC_RAM_END then
347		CAST_ADDR = cast("uint32_t", CAST_ADDR % GC_RAM_START)
348	else
349		log.warn("[MEMORY] Attempt to read from invalid address %08X", tonumber(CAST_ADDR))
350		return false
351	end
352
353	local raddr = cast("LPCVOID", self.dolphin_base_addr + CAST_ADDR)
354	local success = kernel.ReadProcessMemory(self.process_handle, raddr, output, size, memread)
355	if not success then
356		log.debug("[MEMORY] Failed reading from address [%08X] ERROR #%d", CAST_ADDR, tonumber(kernel.GetLastError()))
357	else
358	 	log.trace("[MEMORY] Read 0x%X size 0x%X bytes from 0x%08X = %q", tonumber(memread[0]), size, tonumber(CAST_ADDR), string(output, memread[0]))
359	end
360	return success and memread[0] == size
361end
362
363local memwritten = ffi.new("SIZE_T[1]")
364
365function MEMORY:write(addr, input, size)
366	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
367	local waddr = cast("LPVOID", self.dolphin_base_addr + (addr % GC_RAM_START))
368	local success = kernel.WriteProcessMemory(self.process_handle, waddr, input, size, memwritten)
369	if not success then
370		log.debug("[MEMORY] Failed writing to address [%08X = %08X] ERROR #%d", addr, tonumber(input), tonumber(kernel.GetLastError()))
371	end
372	return success and memwritten[0] == size
373end
374
375return MEMORY