fork/m-overlay

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

BkacjiosAdd Citrus Dolphin to the exe list4720982

v2.1.3
9.6 KiB376 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	["Citrus Dolphin.exe"] = true,
210	["DolphinWx.exe"] = true,
211	["DolphinQt2.exe"] = true,
212}
213
214do
215	local status = new("DWORD[1]")
216
217	function MEMORY:findprocess()
218		if self:hasProcess() then return false end
219
220		local handle
221		local snapshot = kernel.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) -- Create the snapshot
222
223		local pe32 = PROCESSENTRY32_PTR()[0] -- Will store the info about the process
224		pe32.dwSize = sizeof(pe32)
225
226		repeat
227			local name = string(pe32.szExeFile)
228			if valid_process_names[name] then
229				local handle = kernel.OpenProcess(PROCESS_VM_OPERATION + PROCESS_VM_READ + PROCESS_QUERY_INFORMATION, false, pe32.th32ProcessID)
230
231				-- Check if the process is active, we don't want to rehook the closing application
232				if handle ~= nil and kernel.GetExitCodeProcess(handle, status) and status[0] == STILL_ACTIVE then
233					-- We have an active process that matches, let's use it
234					self.process_handle = handle
235					break
236				elseif handle then
237					-- Dolphin is closing.. ignore and close the handle..
238					kernel.CloseHandle(handle)
239				end
240			end
241		until kernel.Process32Next(snapshot, pe32) == 0
242		
243		kernel.CloseHandle(snapshot)
244
245		return self:hasProcess()
246	end
247end
248
249do
250	local status = new("DWORD[1]")
251	
252	function MEMORY:isProcessActive()
253		return self.process_handle ~= nil and kernel.GetExitCodeProcess(self.process_handle, status) and status[0] == STILL_ACTIVE
254	end
255end
256
257function MEMORY:hasProcess()
258	return self.process_handle ~= nil
259end
260
261function MEMORY:clearGamecubeRAMOffset()
262	self.dolphin_base_addr = nil
263end
264
265function MEMORY:hasGamecubeRAMOffset()
266	return self.dolphin_base_addr ~= nil
267end
268
269function MEMORY:getGamecubeRAMOffset()
270	return tonumber(self.dolphin_base_addr)
271end
272
273function MEMORY:getGamecubeRAMSize()
274	return tonumber(self.dolphin_addr_size)
275end
276
277function MEMORY:close()
278	if self:hasProcess() then
279		kernel.CloseHandle(self.process_handle)
280		self.process_handle = nil
281		self.dolphin_base_addr = nil
282	end
283end
284
285function MEMORY:__gc()
286	self:close()
287end
288
289local regionptr = new("ULONG_PTR*[1]")
290
291local NULL = cast("ULONG_PTR", 0x00000000)
292local GC_RAM_SIZE = cast("ULONG_PTR", 0x2000000)
293
294function MEMORY:findGamecubeRAMOffset()
295	local info = MEMORY_BASIC_INFORMATION_PTR()[0]
296
297	local address = regionptr[0]
298
299	-- Scan all virtual address spaces the process is using.
300	while kernel.VirtualQueryEx(self.process_handle, address, info, sizeof(info)) == sizeof(info) do
301		address = address + info.RegionSize / sizeof(info.RegionSize)
302
303		-- Dolphin stores the GameCube RAM address space in 32MB chunks.
304		-- Extended memory override can allow up to 64MB.
305		if (info.RegionSize >= GC_RAM_SIZE and info.RegionSize % GC_RAM_SIZE == 0 and info.Type == MEM_MAPPED) then
306			local wsinfo = PSAPI_WORKING_SET_EX_INFORMATION_PTR()[0]
307			wsinfo.VirtualAddress = info.BaseAddress
308
309			-- Retrieve extended information about the virtual address space
310			if psapi.QueryWorkingSetEx(self.process_handle, wsinfo, sizeof(wsinfo)) == 1 then
311				local flags = tonumber(wsinfo.VirtualAttributes.Flags)
312
313				local base = cast("ULONG_PTR", info.BaseAddress)
314				local region = cast("ULONG_PTR", info.RegionSize)
315
316				-- Check that the VirtualAttributes flags contains VALID and the base address is not null
317				if band(flags, lshift(1, 0)) == 1 and cast("ULONG_PTR", info.BaseAddress) ~= NULL then
318					--log.debug("%08X %x", tonumber(base), tonumber(region))
319					self.dolphin_base_addr = base
320					self.dolphin_addr_size = region
321					return true
322				end
323			end
324		end
325	end
326
327	return false
328end
329
330local GC_RAM_START = cast("uint32_t", 0x80000000)
331local GC_RAM_END = cast("uint32_t", 0x81800000)
332local WII_RAM_START = cast("uint32_t", 0x90000000)
333local WII_RAM_END = cast("uint32_t", 0x94000000)
334
335local WII_RAM_LOCAL_START = cast("uint32_t", 0x02000000)
336
337local CAST_ADDR = ffi.new("uint32_t", 0x00000000)
338local memread = ffi.new("SIZE_T[1]") -- How many bytes are read from memory
339
340function MEMORY:read(addr, output, size)
341	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
342
343	CAST_ADDR = cast("uint32_t", addr)
344
345	if CAST_ADDR >= WII_RAM_START and CAST_ADDR <= WII_RAM_END then
346		CAST_ADDR = cast("uint32_t", WII_RAM_LOCAL_START + (CAST_ADDR % WII_RAM_START))
347	elseif CAST_ADDR >= GC_RAM_START and CAST_ADDR <= GC_RAM_END then
348		CAST_ADDR = cast("uint32_t", CAST_ADDR % GC_RAM_START)
349	else
350		log.warn("[MEMORY] Attempt to read from invalid address %08X", tonumber(CAST_ADDR))
351		return false
352	end
353
354	local raddr = cast("LPCVOID", self.dolphin_base_addr + CAST_ADDR)
355	local success = kernel.ReadProcessMemory(self.process_handle, raddr, output, size, memread)
356	if not success then
357		log.debug("[MEMORY] Failed reading from address [%08X] ERROR #%d", CAST_ADDR, tonumber(kernel.GetLastError()))
358	else
359	 	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]))
360	end
361	return success and memread[0] == size
362end
363
364local memwritten = ffi.new("SIZE_T[1]")
365
366function MEMORY:write(addr, input, size)
367	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
368	local waddr = cast("LPVOID", self.dolphin_base_addr + (addr % GC_RAM_START))
369	local success = kernel.WriteProcessMemory(self.process_handle, waddr, input, size, memwritten)
370	if not success then
371		log.debug("[MEMORY] Failed writing to address [%08X = %08X] ERROR #%d", addr, tonumber(input), tonumber(kernel.GetLastError()))
372	end
373	return success and memwritten[0] == size
374end
375
376return MEMORY