fork/m-overlay
git clone https://git.julia.blue/fork/m-overlay
a8034e9
v2.1.2
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 { 52HANDLE process_handle ; 53ULONG_PTR dolphin_base_addr ; 54ULONG_PTR dolphin_addr_size ; 55} MEMORY_STRUCT ; 56 57typedef struct tagPROCESSENTRY32 { 58DWORD dwSize ; 59DWORD cntUsage ; 60DWORD th32ProcessID ; 61ULONG_PTR th32DefaultHeapID ; // DWORD on 32-bit 62DWORD th32ModuleID ; 63DWORD cntThreads ; 64DWORD th32ParentProcessID ; 65LONG pcPriClassBase ; 66DWORD dwFlags ; 67CHAR szExeFile [ 260 ]; 68} PROCESSENTRY32 , * PPROCESSENTRY32 , * LPPROCESSENTRY32 ; 69 70HANDLE CreateToolhelp32Snapshot ( 71DWORD dwFlags , 72DWORD th32ProcessID 73); 74 75BOOL Process32First ( 76HANDLE hSnapshot , 77LPPROCESSENTRY32 lppe 78); 79 80BOOL Process32Next ( 81HANDLE hSnapshot , 82LPPROCESSENTRY32 lppe 83); 84 85HANDLE OpenProcess ( 86DWORD dwDesiredAccess , 87BOOL bInheritHandle , 88DWORD dwProcessId 89); 90 91BOOL ReadProcessMemory ( 92HANDLE hProcess , 93LPCVOID lpBaseAddress , 94LPVOID lpBuffer , 95SIZE_T nSize , 96SIZE_T * lpNumberOfBytesRead 97); 98 99BOOL WriteProcessMemory ( 100HANDLE hProcess , 101LPVOID lpBaseAddress , 102LPCVOID lpBuffer , 103SIZE_T nSize , 104SIZE_T * lpNumberOfBytesWritten 105); 106 107BOOL CloseHandle ( 108HANDLE hObject 109); 110 111typedef struct _MEMORY_BASIC_INFORMATION { 112PVOID BaseAddress ; 113PVOID AllocationBase ; 114DWORD AllocationProtect ; 115SIZE_T RegionSize ; 116DWORD State ; 117DWORD Protect ; 118DWORD Type ; 119} MEMORY_BASIC_INFORMATION , * PMEMORY_BASIC_INFORMATION ; 120 121typedef union _PSAPI_WORKING_SET_EX_BLOCK { 122ULONG_PTR Flags ; 123/*union { 124struct { 125ULONG_PTR Valid : 1; 126ULONG_PTR ShareCount : 3; 127ULONG_PTR Win32Protection : 11; 128ULONG_PTR Shared : 1; 129ULONG_PTR Node : 6; 130ULONG_PTR Locked : 1; 131ULONG_PTR LargePage : 1; 132ULONG_PTR Reserved : 7; 133ULONG_PTR Bad : 1; 134ULONG_PTR ReservedUlong : 32; 135}; 136struct { 137ULONG_PTR Valid : 1; 138ULONG_PTR Reserved0 : 14; 139ULONG_PTR Shared : 1; 140ULONG_PTR Reserved1 : 15; 141ULONG_PTR Bad : 1; 142ULONG_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 { 148PVOID VirtualAddress ; 149PSAPI_WORKING_SET_EX_BLOCK VirtualAttributes ; 150} PSAPI_WORKING_SET_EX_INFORMATION , * PPSAPI_WORKING_SET_EX_INFORMATION ; 151 152SIZE_T VirtualQueryEx ( 153HANDLE hProcess , 154LPCVOID lpAddress , 155PMEMORY_BASIC_INFORMATION lpBuffer , 156SIZE_T dwLength 157); 158 159BOOL QueryWorkingSetEx ( 160HANDLE hProcess , 161PVOID pv , 162DWORD cb 163); 164 165BOOL GetExitCodeProcess ( 166HANDLE hProcess , 167LPDWORD lpExitCode 168); 169 170DWORD WaitForSingleObject ( 171HANDLE hHandle , 172DWORD 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 ) 194return 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 203return 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 214local status =new ( "DWORD[1]" ) 215 216function MEMORY : findprocess () 217if self : hasProcess () then return false end 218 219local handle 220local snapshot =kernel . CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS , 0 ) -- Create the snapshot 221 222local pe32 =PROCESSENTRY32_PTR ()[ 0 ] -- Will store the info about the process 223pe32 . dwSize =sizeof ( pe32 ) 224 225repeat 226local name =string ( pe32 . szExeFile ) 227if valid_process_names [ name ] then 228local 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 231if 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 233self . process_handle =handle 234break 235elseif handle then 236-- Dolphin is closing.. ignore and close the handle.. 237kernel . CloseHandle ( handle ) 238end 239end 240until kernel . Process32Next ( snapshot , pe32 ) == 0 241 242kernel . CloseHandle ( snapshot ) 243 244return self : hasProcess () 245end 246end 247 248do 249local status =new ( "DWORD[1]" ) 250 251function MEMORY : isProcessActive () 252return self . process_handle ~= nil and kernel . GetExitCodeProcess ( self . process_handle , status ) and status [ 0 ] == STILL_ACTIVE 253end 254end 255 256function MEMORY : hasProcess () 257return self . process_handle ~= nil 258end 259 260function MEMORY : clearGamecubeRAMOffset () 261self . dolphin_base_addr =nil 262end 263 264function MEMORY : hasGamecubeRAMOffset () 265return self . dolphin_base_addr ~= nil 266end 267 268function MEMORY : getGamecubeRAMOffset () 269return tonumber ( self . dolphin_base_addr ) 270end 271 272function MEMORY : getGamecubeRAMSize () 273return tonumber ( self . dolphin_addr_size ) 274end 275 276function MEMORY : close () 277if self : hasProcess () then 278kernel . CloseHandle ( self . process_handle ) 279self . process_handle =nil 280self . dolphin_base_addr =nil 281end 282end 283 284function MEMORY : __gc () 285self : 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 () 294local info =MEMORY_BASIC_INFORMATION_PTR ()[ 0 ] 295 296local address =regionptr [ 0 ] 297 298-- Scan all virtual address spaces the process is using. 299while kernel . VirtualQueryEx ( self . process_handle , address , info , sizeof ( info )) == sizeof ( info ) do 300address =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. 304if ( info . RegionSize >= GC_RAM_SIZE and info . RegionSize % GC_RAM_SIZE == 0 and info . Type == MEM_MAPPED ) then 305local wsinfo =PSAPI_WORKING_SET_EX_INFORMATION_PTR ()[ 0 ] 306wsinfo . VirtualAddress =info . BaseAddress 307 308-- Retrieve extended information about the virtual address space 309if psapi . QueryWorkingSetEx ( self . process_handle , wsinfo , sizeof ( wsinfo )) == 1 then 310local flags =tonumber ( wsinfo . VirtualAttributes . Flags ) 311 312local base =cast ( "ULONG_PTR" , info . BaseAddress ) 313local region =cast ( "ULONG_PTR" , info . RegionSize ) 314 315-- Check that the VirtualAttributes flags contains VALID and the base address is not null 316if band ( flags , lshift ( 1 , 0 )) == 1 and cast ( "ULONG_PTR" , info . BaseAddress ) ~= NULL then 317--log.debug("%08X %x", tonumber(base), tonumber(region)) 318self . dolphin_base_addr =base 319self . dolphin_addr_size =region 320return true 321end 322end 323end 324end 325 326return 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 ) 340if not self : hasProcess () or not self : hasGamecubeRAMOffset () then return false end 341 342CAST_ADDR =cast ( "uint32_t" , addr ) 343 344if CAST_ADDR >= WII_RAM_START and CAST_ADDR <= WII_RAM_END then 345CAST_ADDR =cast ( "uint32_t" , WII_RAM_LOCAL_START + ( CAST_ADDR % WII_RAM_START )) 346elseif CAST_ADDR >= GC_RAM_START and CAST_ADDR <= GC_RAM_END then 347CAST_ADDR =cast ( "uint32_t" , CAST_ADDR % GC_RAM_START ) 348else 349log . warn ( "[MEMORY] Attempt to read from invalid address %08X" , tonumber ( CAST_ADDR )) 350return false 351end 352 353local raddr =cast ( "LPCVOID" , self . dolphin_base_addr + CAST_ADDR ) 354local success =kernel . ReadProcessMemory ( self . process_handle , raddr , output , size , memread ) 355if not success then 356log . debug ( "[MEMORY] Failed reading from address [%08X] ERROR #%d" , CAST_ADDR , tonumber ( kernel . GetLastError ())) 357else 358log . trace ( "[MEMORY] Read 0x%X size 0x%X bytes from 0x%08X = %q" , tonumber ( memread [ 0 ]), size , tonumber ( CAST_ADDR ), string ( output , memread [ 0 ])) 359end 360return success and memread [ 0 ] == size 361end 362 363local memwritten =ffi . new ( "SIZE_T[1]" ) 364 365function MEMORY : write ( addr , input , size ) 366if not self : hasProcess () or not self : hasGamecubeRAMOffset () then return false end 367local waddr =cast ( "LPVOID" , self . dolphin_base_addr + ( addr % GC_RAM_START )) 368local success =kernel . WriteProcessMemory ( self . process_handle , waddr , input , size , memwritten ) 369if not success then 370log . debug ( "[MEMORY] Failed writing to address [%08X = %08X] ERROR #%d" , addr , tonumber ( input ), tonumber ( kernel . GetLastError ())) 371end 372return success and memwritten [ 0 ] == size 373end 374 375return MEMORY