fork/m-overlay
git clone https://git.julia.blue/fork/m-overlay
4720982
v2.1.3
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[ "Citrus Dolphin.exe" ] =true , 210[ "DolphinWx.exe" ] =true , 211[ "DolphinQt2.exe" ] =true , 212} 213 214do 215local status =new ( "DWORD[1]" ) 216 217function MEMORY : findprocess () 218if self : hasProcess () then return false end 219 220local handle 221local snapshot =kernel . CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS , 0 ) -- Create the snapshot 222 223local pe32 =PROCESSENTRY32_PTR ()[ 0 ] -- Will store the info about the process 224pe32 . dwSize =sizeof ( pe32 ) 225 226repeat 227local name =string ( pe32 . szExeFile ) 228if valid_process_names [ name ] then 229local 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 232if 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 234self . process_handle =handle 235break 236elseif handle then 237-- Dolphin is closing.. ignore and close the handle.. 238kernel . CloseHandle ( handle ) 239end 240end 241until kernel . Process32Next ( snapshot , pe32 ) == 0 242 243kernel . CloseHandle ( snapshot ) 244 245return self : hasProcess () 246end 247end 248 249do 250local status =new ( "DWORD[1]" ) 251 252function MEMORY : isProcessActive () 253return self . process_handle ~= nil and kernel . GetExitCodeProcess ( self . process_handle , status ) and status [ 0 ] == STILL_ACTIVE 254end 255end 256 257function MEMORY : hasProcess () 258return self . process_handle ~= nil 259end 260 261function MEMORY : clearGamecubeRAMOffset () 262self . dolphin_base_addr =nil 263end 264 265function MEMORY : hasGamecubeRAMOffset () 266return self . dolphin_base_addr ~= nil 267end 268 269function MEMORY : getGamecubeRAMOffset () 270return tonumber ( self . dolphin_base_addr ) 271end 272 273function MEMORY : getGamecubeRAMSize () 274return tonumber ( self . dolphin_addr_size ) 275end 276 277function MEMORY : close () 278if self : hasProcess () then 279kernel . CloseHandle ( self . process_handle ) 280self . process_handle =nil 281self . dolphin_base_addr =nil 282end 283end 284 285function MEMORY : __gc () 286self : 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 () 295local info =MEMORY_BASIC_INFORMATION_PTR ()[ 0 ] 296 297local address =regionptr [ 0 ] 298 299-- Scan all virtual address spaces the process is using. 300while kernel . VirtualQueryEx ( self . process_handle , address , info , sizeof ( info )) == sizeof ( info ) do 301address =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. 305if ( info . RegionSize >= GC_RAM_SIZE and info . RegionSize % GC_RAM_SIZE == 0 and info . Type == MEM_MAPPED ) then 306local wsinfo =PSAPI_WORKING_SET_EX_INFORMATION_PTR ()[ 0 ] 307wsinfo . VirtualAddress =info . BaseAddress 308 309-- Retrieve extended information about the virtual address space 310if psapi . QueryWorkingSetEx ( self . process_handle , wsinfo , sizeof ( wsinfo )) == 1 then 311local flags =tonumber ( wsinfo . VirtualAttributes . Flags ) 312 313local base =cast ( "ULONG_PTR" , info . BaseAddress ) 314local region =cast ( "ULONG_PTR" , info . RegionSize ) 315 316-- Check that the VirtualAttributes flags contains VALID and the base address is not null 317if band ( flags , lshift ( 1 , 0 )) == 1 and cast ( "ULONG_PTR" , info . BaseAddress ) ~= NULL then 318--log.debug("%08X %x", tonumber(base), tonumber(region)) 319self . dolphin_base_addr =base 320self . dolphin_addr_size =region 321return true 322end 323end 324end 325end 326 327return 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 ) 341if not self : hasProcess () or not self : hasGamecubeRAMOffset () then return false end 342 343CAST_ADDR =cast ( "uint32_t" , addr ) 344 345if CAST_ADDR >= WII_RAM_START and CAST_ADDR <= WII_RAM_END then 346CAST_ADDR =cast ( "uint32_t" , WII_RAM_LOCAL_START + ( CAST_ADDR % WII_RAM_START )) 347elseif CAST_ADDR >= GC_RAM_START and CAST_ADDR <= GC_RAM_END then 348CAST_ADDR =cast ( "uint32_t" , CAST_ADDR % GC_RAM_START ) 349else 350log . warn ( "[MEMORY] Attempt to read from invalid address %08X" , tonumber ( CAST_ADDR )) 351return false 352end 353 354local raddr =cast ( "LPCVOID" , self . dolphin_base_addr + CAST_ADDR ) 355local success =kernel . ReadProcessMemory ( self . process_handle , raddr , output , size , memread ) 356if not success then 357log . debug ( "[MEMORY] Failed reading from address [%08X] ERROR #%d" , CAST_ADDR , tonumber ( kernel . GetLastError ())) 358else 359log . trace ( "[MEMORY] Read 0x%X size 0x%X bytes from 0x%08X = %q" , tonumber ( memread [ 0 ]), size , tonumber ( CAST_ADDR ), string ( output , memread [ 0 ])) 360end 361return success and memread [ 0 ] == size 362end 363 364local memwritten =ffi . new ( "SIZE_T[1]" ) 365 366function MEMORY : write ( addr , input , size ) 367if not self : hasProcess () or not self : hasGamecubeRAMOffset () then return false end 368local waddr =cast ( "LPVOID" , self . dolphin_base_addr + ( addr % GC_RAM_START )) 369local success =kernel . WriteProcessMemory ( self . process_handle , waddr , input , size , memwritten ) 370if not success then 371log . debug ( "[MEMORY] Failed writing to address [%08X = %08X] ERROR #%d" , addr , tonumber ( input ), tonumber ( kernel . GetLastError ())) 372end 373return success and memwritten [ 0 ] == size 374end 375 376return MEMORY