diff --git a/CMakeLists.txt b/CMakeLists.txt index 21e8fdd..e89b8f3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -80,6 +80,7 @@ add_executable(wibo src/loader.cpp src/resources.cpp src/module_registry.cpp + src/winapi_segments.cpp src/main.cpp src/processes.cpp src/strutil.cpp diff --git a/dll/advapi32/processthreadsapi.cpp b/dll/advapi32/processthreadsapi.cpp index 023a3b6..59a199c 100644 --- a/dll/advapi32/processthreadsapi.cpp +++ b/dll/advapi32/processthreadsapi.cpp @@ -8,6 +8,7 @@ namespace advapi32 { BOOL WIN_FUNC OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("OpenProcessToken(%p, %u, %p)\n", ProcessHandle, DesiredAccess, TokenHandle); if (!TokenHandle) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/advapi32/securitybaseapi.cpp b/dll/advapi32/securitybaseapi.cpp index 12b17a0..b04db89 100644 --- a/dll/advapi32/securitybaseapi.cpp +++ b/dll/advapi32/securitybaseapi.cpp @@ -101,6 +101,7 @@ bool writeLocalSystemSid(Sid *sid) { namespace advapi32 { BOOL WIN_FUNC InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("InitializeAcl(%p, %u, %u)\n", pAcl, nAclLength, dwAclRevision); if (!pAcl) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -131,6 +132,7 @@ BOOL WIN_FUNC InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision) { } BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("AddAccessAllowedAce(%p, %u, 0x%x, %p)\n", pAcl, dwAceRevision, AccessMask, pSid); if (!pAcl || !pSid) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -200,6 +202,7 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa } BOOL WIN_FUNC FindFirstFreeAce(PACL pAcl, LPVOID *pAce) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindFirstFreeAce(%p, %p)\n", pAcl, pAce); if (!pAce) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -224,6 +227,7 @@ BOOL WIN_FUNC FindFirstFreeAce(PACL pAcl, LPVOID *pAce) { BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL *pDacl, LPBOOL lpbDaclDefaulted) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSecurityDescriptorDacl(%p, %p, %p, %p)\n", pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted); if (!pSecurityDescriptor) { @@ -261,6 +265,7 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor } PSID_IDENTIFIER_AUTHORITY WIN_FUNC GetSidIdentifierAuthority(PSID pSid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSidIdentifierAuthority(%p)\n", pSid); if (!pSid) { wibo::lastError = ERROR_INVALID_SID; @@ -276,6 +281,7 @@ PSID_IDENTIFIER_AUTHORITY WIN_FUNC GetSidIdentifierAuthority(PSID pSid) { } PUCHAR WIN_FUNC GetSidSubAuthorityCount(PSID pSid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSidSubAuthorityCount(%p)\n", pSid); if (!pSid) { wibo::lastError = ERROR_INVALID_SID; @@ -291,6 +297,7 @@ PUCHAR WIN_FUNC GetSidSubAuthorityCount(PSID pSid) { } PDWORD WIN_FUNC GetSidSubAuthority(PSID pSid, DWORD nSubAuthority) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSidSubAuthority(%p, %u)\n", pSid, nSubAuthority); if (!pSid) { wibo::lastError = ERROR_INVALID_SID; @@ -306,6 +313,7 @@ PDWORD WIN_FUNC GetSidSubAuthority(PSID pSid, DWORD nSubAuthority) { } BOOL WIN_FUNC ImpersonateLoggedOnUser(HANDLE hToken) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: ImpersonateLoggedOnUser(%p)\n", hToken); (void)hToken; wibo::lastError = ERROR_SUCCESS; @@ -314,6 +322,7 @@ BOOL WIN_FUNC ImpersonateLoggedOnUser(HANDLE hToken) { BOOL WIN_FUNC DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, void *lpTokenAttributes, DWORD ImpersonationLevel, DWORD TokenType, PHANDLE phNewToken) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DuplicateTokenEx(%p, 0x%x, %p, %u, %u, %p)\n", hExistingToken, dwDesiredAccess, lpTokenAttributes, ImpersonationLevel, TokenType, phNewToken); (void)lpTokenAttributes; @@ -336,6 +345,7 @@ BOOL WIN_FUNC DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, voi } BOOL WIN_FUNC CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CopySid(%u, %p, %p)\n", nDestinationSidLength, pDestinationSid, pSourceSid); if (!pDestinationSid || !pSourceSid) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -353,6 +363,7 @@ BOOL WIN_FUNC CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pS } BOOL WIN_FUNC InitializeSid(PSID sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("InitializeSid(%p, %p, %u)\n", sid, pIdentifierAuthority, nSubAuthorityCount); if (!sid || !pIdentifierAuthority) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -374,6 +385,7 @@ BOOL WIN_FUNC InitializeSid(PSID sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAutho } BOOL WIN_FUNC EqualSid(PSID pSid1, PSID pSid2) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("EqualSid(%p, %p)\n", pSid1, pSid2); if (!pSid1 || !pSid2) { wibo::lastError = ERROR_INVALID_SID; @@ -398,6 +410,7 @@ BOOL WIN_FUNC EqualSid(PSID pSid1, PSID pSid2) { BOOL WIN_FUNC SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetKernelObjectSecurity(%p, 0x%x, %p)\n", Handle, SecurityInformation, SecurityDescriptor); (void)SecurityInformation; if (!SecurityDescriptor) { @@ -414,6 +427,7 @@ BOOL WIN_FUNC SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION Securi } BOOL WIN_FUNC InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("InitializeSecurityDescriptor(%p, %u)\n", pSecurityDescriptor, dwRevision); if (!pSecurityDescriptor || dwRevision != SECURITY_DESCRIPTOR_REVISION) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -432,6 +446,7 @@ BOOL WIN_FUNC InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescrip BOOL WIN_FUNC SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetSecurityDescriptorDacl(%p, %u, %p, %u)\n", pSecurityDescriptor, bDaclPresent, pDacl, bDaclDefaulted); if (!pSecurityDescriptor || pSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -454,6 +469,7 @@ BOOL WIN_FUNC SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, LPDWORD ReturnLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetTokenInformation(%p, %u, %p, %u, %p)\n", TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength, ReturnLength); if (!ReturnLength) { @@ -537,6 +553,7 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To BOOL WIN_FUNC AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, LPDWORD ReturnLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("AdjustTokenPrivileges(%p, %u, %p, %u, %p, %p)\n", TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength); (void)TokenHandle; @@ -551,6 +568,7 @@ BOOL WIN_FUNC AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivilege BOOL WIN_FUNC SetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetTokenInformation(%p, %u, %p, %u)\n", TokenHandle, TokenInformationClass, TokenInformation, TokenInformationLength); (void)TokenInformationClass; diff --git a/dll/advapi32/winbase.cpp b/dll/advapi32/winbase.cpp index 5c2aa44..3fbb6a3 100644 --- a/dll/advapi32/winbase.cpp +++ b/dll/advapi32/winbase.cpp @@ -83,6 +83,7 @@ namespace advapi32 { BOOL WIN_FUNC LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cchName, LPWSTR ReferencedDomainName, LPDWORD cchReferencedDomainName, SID_NAME_USE *peUse) { + WIN_API_SEGMENT_GUARD(); std::string systemName = lpSystemName ? wideStringToString(lpSystemName) : std::string("(null)"); DEBUG_LOG("LookupAccountSidW(%s, %p, %p, %p, %p, %p, %p)\n", systemName.c_str(), Sid, Name, cchName, ReferencedDomainName, cchReferencedDomainName, peUse); @@ -113,6 +114,7 @@ BOOL WIN_FUNC LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPD } BOOL WIN_FUNC LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LookupPrivilegeValueA(%s, %s, %p)\n", lpSystemName ? lpSystemName : "(null)", lpName ? lpName : "(null)", lpLuid); (void)lpSystemName; // only local lookup supported @@ -128,6 +130,7 @@ BOOL WIN_FUNC LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lp } BOOL WIN_FUNC LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LookupPrivilegeValueW(%p, %p, %p)\n", lpSystemName, lpName, lpLuid); (void)lpSystemName; // only local lookup supported if (!lpName || !lpLuid) { @@ -143,6 +146,7 @@ BOOL WIN_FUNC LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID } BOOL WIN_FUNC GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetUserNameA(%p, %p)\n", lpBuffer, pcbBuffer); if (!pcbBuffer) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -162,6 +166,7 @@ BOOL WIN_FUNC GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer) { } BOOL WIN_FUNC GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetUserNameW(%p, %p)\n", lpBuffer, pcbBuffer); if (!pcbBuffer) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/advapi32/wincrypt.cpp b/dll/advapi32/wincrypt.cpp index 9daae14..d6b0fba 100644 --- a/dll/advapi32/wincrypt.cpp +++ b/dll/advapi32/wincrypt.cpp @@ -205,6 +205,7 @@ HCRYPTHASH hashHandleFromObject(HashObject *hash) { return static_cast(static_cast(hProv)), dwFlags); (void)hProv; (void)dwFlags; @@ -214,6 +215,7 @@ BOOL WIN_FUNC CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags) { BOOL WIN_FUNC CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: CryptAcquireContextW(%p, %p, %p, %u, %u)\n", phProv, pszContainer, pszProvider, dwProvType, dwFlags); // to quote the guy above me: screw them for now @@ -228,6 +230,7 @@ BOOL WIN_FUNC CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPC } BOOL WIN_FUNC CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CryptGenRandom(%p)\n", reinterpret_cast(static_cast(hProv))); (void)hProv; if (!pbBuffer || dwLen == 0) { @@ -246,6 +249,7 @@ BOOL WIN_FUNC CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) { } BOOL WIN_FUNC CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CryptCreateHash(%p, %u, %p, %u, %p)\n", reinterpret_cast(static_cast(hProv)), Algid, reinterpret_cast(static_cast(hKey)), dwFlags, phHash); (void)hProv; @@ -276,6 +280,7 @@ BOOL WIN_FUNC CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DW } BOOL WIN_FUNC CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CryptHashData(%p, %p, %u, %u)\n", reinterpret_cast(static_cast(hHash)), pbData, dwDataLen, dwFlags); if (dwFlags != 0) { @@ -297,6 +302,7 @@ BOOL WIN_FUNC CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLe } BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CryptGetHashParam(%p, %u, %p, %p, %u)\n", reinterpret_cast(static_cast(hHash)), dwParam, pbData, pdwDataLen, dwFlags); if (dwFlags != 0 || !pdwDataLen) { @@ -382,6 +388,7 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D } BOOL WIN_FUNC CryptDestroyHash(HCRYPTHASH hHash) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CryptDestroyHash(%p)\n", reinterpret_cast(static_cast(hHash))); auto *hash = hashObjectFromHandle(hHash); if (!hash) { diff --git a/dll/advapi32/winreg.cpp b/dll/advapi32/winreg.cpp index 617202b..80b77a6 100644 --- a/dll/advapi32/winreg.cpp +++ b/dll/advapi32/winreg.cpp @@ -128,6 +128,7 @@ namespace advapi32 { LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, REGSAM samDesired, void *lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition) { + WIN_API_SEGMENT_GUARD(); std::string subKeyString = lpSubKey ? wideStringToString(lpSubKey) : std::string("(null)"); std::string classString = lpClass ? wideStringToString(lpClass) : std::string("(null)"); DEBUG_LOG("RegCreateKeyExW(%p, %s, %u, %s, 0x%x, 0x%x, %p, %p, %p)\n", hKey, subKeyString.c_str(), Reserved, @@ -196,6 +197,7 @@ LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LP LSTATUS WIN_FUNC RegCreateKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass, DWORD dwOptions, REGSAM samDesired, void *lpSecurityAttributes, PHKEY phkResult, LPDWORD lpdwDisposition) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegCreateKeyExA(%p, %s, %u, %s, 0x%x, 0x%x, %p, %p, %p)\n", hKey, lpSubKey ? lpSubKey : "(null)", Reserved, lpClass ? lpClass : "(null)", dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition); @@ -213,6 +215,7 @@ LSTATUS WIN_FUNC RegCreateKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPS } LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult) { + WIN_API_SEGMENT_GUARD(); std::string subKeyString = lpSubKey ? wideStringToString(lpSubKey) : std::string("(null)"); DEBUG_LOG("RegOpenKeyExW(%p, %s, %u, 0x%x, %p)\n", hKey, subKeyString.c_str(), ulOptions, samDesired, phkResult); if (!phkResult) { @@ -271,6 +274,7 @@ LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REG } LSTATUS WIN_FUNC RegOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegOpenKeyExA(%p, %s, %u, 0x%x, %p)\n", hKey, lpSubKey ? lpSubKey : "(null)", ulOptions, samDesired, phkResult); LPCWSTR widePtr = nullptr; @@ -284,6 +288,7 @@ LSTATUS WIN_FUNC RegOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGS LSTATUS WIN_FUNC RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, BYTE *lpData, LPDWORD lpcbData) { + WIN_API_SEGMENT_GUARD(); std::string valueName = lpValueName ? wideStringToString(lpValueName) : std::string("(default)"); DEBUG_LOG("RegQueryValueExW(%p, %s, %p, %p, %p, %p)\n", hKey, valueName.c_str(), lpReserved, lpType, lpData, lpcbData); @@ -305,6 +310,7 @@ LSTATUS WIN_FUNC RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpRese LSTATUS WIN_FUNC RegQueryValueExA(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, BYTE *lpData, LPDWORD lpcbData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegQueryValueExA(%p, %s, %p, %p, %p, %p)\n", hKey, lpValueName ? lpValueName : "(null)", lpReserved, lpType, lpData, lpcbData); std::vector valueWideStorage; @@ -317,6 +323,7 @@ LSTATUS WIN_FUNC RegQueryValueExA(HKEY hKey, LPCSTR lpValueName, LPDWORD lpReser LSTATUS WIN_FUNC RegEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcchClass, FILETIME *lpftLastWriteTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegEnumKeyExW(%p, %u, %p, %p, %p, %p, %p, %p)\n", hKey, dwIndex, lpName, lpcchName, lpReserved, lpClass, lpcchClass, lpftLastWriteTime); (void)hKey; @@ -344,6 +351,7 @@ LSTATUS WIN_FUNC RegEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD LSTATUS WIN_FUNC RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcchName, LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcchClass, FILETIME *lpftLastWriteTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegEnumKeyExA(%p, %u, %p, %p, %p, %p, %p, %p)\n", hKey, dwIndex, lpName, lpcchName, lpReserved, lpClass, lpcchClass, lpftLastWriteTime); (void)hKey; @@ -370,6 +378,7 @@ LSTATUS WIN_FUNC RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD l } LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RegCloseKey(%p)\n", hKey); if (isPredefinedKeyHandle(hKey)) { wibo::lastError = ERROR_SUCCESS; diff --git a/dll/bcrypt.cpp b/dll/bcrypt.cpp index 3f64b01..0bb94a6 100644 --- a/dll/bcrypt.cpp +++ b/dll/bcrypt.cpp @@ -32,6 +32,7 @@ bool fillWithSystemRandom(PUCHAR buffer, size_t length) { namespace bcrypt { NTSTATUS WIN_FUNC BCryptGenRandom(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbBuffer, ULONG cbBuffer, ULONG dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("BCryptGenRandom(%p, %p, %lu, %lu)\n", hAlgorithm, pbBuffer, cbBuffer, dwFlags); if (pbBuffer == nullptr && cbBuffer != 0) return STATUS_INVALID_HANDLE; diff --git a/dll/crt.cpp b/dll/crt.cpp index ec420a8..ee7493e 100644 --- a/dll/crt.cpp +++ b/dll/crt.cpp @@ -40,6 +40,7 @@ std::vector<_PVFV> atexitFuncs; _invalid_parameter_handler invalidParameterHandler = nullptr; void WIN_ENTRY _initterm(const _PVFV *ppfn, const _PVFV *end) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_initterm(%p, %p)\n", ppfn, end); do { if (_PVFV pfn = *++ppfn) { @@ -50,6 +51,7 @@ void WIN_ENTRY _initterm(const _PVFV *ppfn, const _PVFV *end) { } int WIN_ENTRY _initterm_e(const _PIFV *ppfn, const _PIFV *end) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_initterm_e(%p, %p)\n", ppfn, end); do { if (_PIFV pfn = *++ppfn) { @@ -62,36 +64,45 @@ int WIN_ENTRY _initterm_e(const _PIFV *ppfn, const _PIFV *end) { return 0; } -void WIN_ENTRY _set_app_type(_crt_app_type type) { DEBUG_LOG("STUB: _set_app_type(%i)\n", type); } +void WIN_ENTRY _set_app_type(_crt_app_type type) { + WIN_API_SEGMENT_GUARD(); + DEBUG_LOG("STUB: _set_app_type(%i)\n", type); +} int WIN_ENTRY _set_fmode(int mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_set_fmode(%i)\n", mode); _fmode = mode; return 0; } int *WIN_ENTRY __p__commode() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__commode()\n"); return &_commode; } int *WIN_ENTRY __p__fmode() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__fmode()\n"); return &_fmode; } int WIN_ENTRY _crt_atexit(void (*func)()) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_crt_atexit(%p)\n", func); atexitFuncs.push_back(func); return 0; } int WIN_ENTRY _configure_narrow_argv(_crt_argv_mode mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _configure_narrow_argv(%i)\n", mode); return 0; } _invalid_parameter_handler WIN_ENTRY _set_invalid_parameter_handler(_invalid_parameter_handler newHandler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _set_invalid_parameter_handler(%p)\n", newHandler); _invalid_parameter_handler oldHandler = invalidParameterHandler; invalidParameterHandler = newHandler; @@ -99,129 +110,154 @@ _invalid_parameter_handler WIN_ENTRY _set_invalid_parameter_handler(_invalid_par } int WIN_ENTRY _controlfp_s(unsigned int *currentControl, unsigned int newControl, unsigned int mask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _controlfp_s(%p, %u, %u)\n", currentControl, newControl, mask); return 0; } int WIN_ENTRY _configthreadlocale(int per_thread_locale_type) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _configthreadlocale(%i)\n", per_thread_locale_type); return 0; } int WIN_ENTRY _initialize_narrow_environment() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _initialize_narrow_environment()\n"); return 0; } int WIN_ENTRY _set_new_mode(int newhandlermode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _set_new_mode(%i)\n", newhandlermode); return 0; } char **WIN_ENTRY _get_initial_narrow_environment() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_get_initial_narrow_environment()\n"); return environ; } char ***WIN_ENTRY __p__environ() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__environ()\n"); return &environ; } char ***WIN_ENTRY __p___argv() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p___argv()\n"); return &wibo::argv; } int *WIN_ENTRY __p___argc() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p___argc()\n"); return &wibo::argc; } size_t WIN_ENTRY strlen(const char *str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strlen(%p)\n", str); return ::strlen(str); } int WIN_ENTRY strcmp(const char *lhs, const char *rhs) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcmp(%p, %p)\n", lhs, rhs); return ::strcmp(lhs, rhs); } int WIN_ENTRY strncmp(const char *lhs, const char *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strncmp(%p, %p, %zu)\n", lhs, rhs, count); return ::strncmp(lhs, rhs, count); } char *WIN_ENTRY strcpy(char *dest, const char *src) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcpy(%p, %p)\n", dest, src); return ::strcpy(dest, src); } void *WIN_ENTRY malloc(size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("malloc(%zu)\n", size); return ::malloc(size); } void *WIN_ENTRY calloc(size_t count, size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("calloc(%zu, %zu)\n", count, size); return ::calloc(count, size); } void *WIN_ENTRY realloc(void *ptr, size_t newSize) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("realloc(%p, %zu)\n", ptr, newSize); return ::realloc(ptr, newSize); } void WIN_ENTRY free(void *ptr) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("free(%p)\n", ptr); ::free(ptr); } void *WIN_ENTRY memcpy(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memcpy(%p, %p, %zu)\n", dest, src, count); return std::memcpy(dest, src, count); } void *WIN_ENTRY memmove(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memmove(%p, %p, %zu)\n", dest, src, count); return std::memmove(dest, src, count); } void *WIN_ENTRY memset(void *dest, int ch, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memset(%p, %i, %zu)\n", dest, ch, count); return std::memset(dest, ch, count); } int WIN_ENTRY memcmp(const void *lhs, const void *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memcmp(%p, %p, %zu)\n", lhs, rhs, count); return std::memcmp(lhs, rhs, count); } int WIN_ENTRY __setusermatherr(void *handler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: __setusermatherr(%p)\n", handler); return 0; } int WIN_ENTRY _initialize_onexit_table(void *table) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _initialize_onexit_table(%p)\n", table); wibo::registerOnExitTable(table); return 0; } int WIN_ENTRY _register_onexit_function(void *table, void (*func)()) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _register_onexit_function(%p, %p)\n", table, func); wibo::addOnExitFunction(table, func); return 0; } int WIN_ENTRY _execute_onexit_table(void *table) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _execute_onexit_table(%p)\n", table); wibo::executeOnExitTable(table); return 0; } void WIN_ENTRY exit(int status) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("exit(%i)\n", status); for (auto it = atexitFuncs.rbegin(); it != atexitFuncs.rend(); ++it) { DEBUG_LOG("Calling atexit function %p\n", *it); @@ -231,6 +267,7 @@ void WIN_ENTRY exit(int status) { } void WIN_ENTRY _cexit(void) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_cexit()\n"); for (auto it = atexitFuncs.rbegin(); it != atexitFuncs.rend(); ++it) { DEBUG_LOG("Calling atexit function %p\n", *it); @@ -239,11 +276,13 @@ void WIN_ENTRY _cexit(void) { } void WIN_ENTRY _exit(int status) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_exit(%i)\n", status); ::_exit(status); } void WIN_ENTRY abort(void) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("abort()\n"); std::abort(); } @@ -251,11 +290,13 @@ void WIN_ENTRY abort(void) { using signal_handler = void (*)(int); signal_handler WIN_ENTRY signal(int signum, signal_handler handler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("signal(%i, %p)\n", signum, handler); return std::signal(signum, handler); } void *WIN_ENTRY __acrt_iob_func(unsigned int index) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__acrt_iob_func(%u)\n", index); if (index == 0) return stdin; @@ -268,12 +309,14 @@ void *WIN_ENTRY __acrt_iob_func(unsigned int index) { int WIN_ENTRY __stdio_common_vfprintf(unsigned long long options, FILE *stream, const char *format, void *locale, va_list args) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__stdio_common_vfprintf(%llu, %p, %s, %p, %p)\n", options, stream, format, locale, args); return vfprintf(stream, format, args); } int WIN_ENTRY __stdio_common_vsprintf(unsigned long long options, char *buffer, size_t len, const char *format, void *locale, va_list args) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__stdio_common_vsprintf(%llu, %p, %zu, %s, %p, ...)\n", options, buffer, len, format, locale); if (!buffer || !format) return -1; diff --git a/dll/kernel32/debugapi.cpp b/dll/kernel32/debugapi.cpp index bcae4c7..ebd1dae 100644 --- a/dll/kernel32/debugapi.cpp +++ b/dll/kernel32/debugapi.cpp @@ -5,6 +5,7 @@ namespace kernel32 { BOOL WIN_FUNC IsDebuggerPresent() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: IsDebuggerPresent()\n"); wibo::lastError = ERROR_SUCCESS; return FALSE; diff --git a/dll/kernel32/errhandlingapi.cpp b/dll/kernel32/errhandlingapi.cpp index 9e387ab..34efe1f 100644 --- a/dll/kernel32/errhandlingapi.cpp +++ b/dll/kernel32/errhandlingapi.cpp @@ -14,17 +14,20 @@ namespace kernel32 { void setLastErrorFromErrno() { wibo::lastError = wibo::winErrorFromErrno(errno); } DWORD WIN_FUNC GetLastError() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLastError() -> %u\n", wibo::lastError); return wibo::lastError; } void WIN_FUNC SetLastError(DWORD dwErrCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetLastError(%u)\n", dwErrCode); wibo::lastError = dwErrCode; } void WIN_FUNC RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, const ULONG_PTR *lpArguments) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RaiseException(0x%x, 0x%x, %u, %p)\n", dwExceptionCode, dwExceptionFlags, nNumberOfArguments, lpArguments); (void)dwExceptionFlags; @@ -34,12 +37,14 @@ void WIN_FUNC RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWOR } PVOID WIN_FUNC AddVectoredExceptionHandler(ULONG First, PVECTORED_EXCEPTION_HANDLER Handler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: AddVectoredExceptionHandler(%u, %p)\n", First, Handler); return reinterpret_cast(Handler); } LPTOP_LEVEL_EXCEPTION_FILTER WIN_FUNC SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetUnhandledExceptionFilter(%p)\n", lpTopLevelExceptionFilter); LPTOP_LEVEL_EXCEPTION_FILTER previous = g_topLevelExceptionFilter; g_topLevelExceptionFilter = lpTopLevelExceptionFilter; @@ -47,11 +52,13 @@ SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilt } LONG WIN_FUNC UnhandledExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: UnhandledExceptionFilter(%p)\n", ExceptionInfo); return EXCEPTION_EXECUTE_HANDLER; } UINT WIN_FUNC SetErrorMode(UINT uMode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetErrorMode(%u)\n", uMode); UINT previous = g_processErrorMode; g_processErrorMode = uMode; diff --git a/dll/kernel32/fibersapi.cpp b/dll/kernel32/fibersapi.cpp index 5b2e046..c2612ba 100644 --- a/dll/kernel32/fibersapi.cpp +++ b/dll/kernel32/fibersapi.cpp @@ -13,6 +13,7 @@ LPVOID g_flsValues[kMaxFlsValues] = {nullptr}; namespace kernel32 { DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FlsAlloc(%p)", lpCallback); // If the function succeeds, the return value is an FLS index initialized to zero. for (DWORD i = 0; i < kMaxFlsValues; i++) { @@ -29,6 +30,7 @@ DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) { } BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FlsFree(%u)\n", dwFlsIndex); if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) { g_flsValuesUsed[dwFlsIndex] = false; @@ -40,6 +42,7 @@ BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) { } PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("FlsGetValue(%u)\n", dwFlsIndex); PVOID result = nullptr; if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) { @@ -54,6 +57,7 @@ PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) { } BOOL WIN_FUNC FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("FlsSetValue(%u, %p)\n", dwFlsIndex, lpFlsData); if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) { g_flsValues[dwFlsIndex] = lpFlsData; diff --git a/dll/kernel32/fileapi.cpp b/dll/kernel32/fileapi.cpp index bd8e4c0..a3dcffb 100644 --- a/dll/kernel32/fileapi.cpp +++ b/dll/kernel32/fileapi.cpp @@ -294,6 +294,7 @@ void resetOverlappedEvent(OVERLAPPED *ov) { } // namespace DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) { + WIN_API_SEGMENT_GUARD(); if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; return INVALID_FILE_ATTRIBUTES; @@ -332,6 +333,7 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) { } DWORD WIN_FUNC GetFileAttributesW(LPCWSTR lpFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileAttributesW -> "); if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -342,6 +344,7 @@ DWORD WIN_FUNC GetFileAttributesW(LPCWSTR lpFileName) { } UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetDriveTypeA(%s)\n", lpRootPathName ? lpRootPathName : "(null)"); (void)lpRootPathName; wibo::lastError = ERROR_SUCCESS; @@ -349,6 +352,7 @@ UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) { } UINT WIN_FUNC GetDriveTypeW(LPCWSTR lpRootPathName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetDriveTypeW(%p)\n", lpRootPathName); (void)lpRootPathName; wibo::lastError = ERROR_SUCCESS; @@ -359,6 +363,7 @@ BOOL WIN_FUNC GetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuf LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetVolumeInformationA(%s)\n", lpRootPathName ? lpRootPathName : "(null)"); if (lpVolumeNameBuffer && nVolumeNameSize > 0) { lpVolumeNameBuffer[0] = '\0'; @@ -388,6 +393,7 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetVolumeInformationW(%p)\n", lpRootPathName); if (lpVolumeNameBuffer && nVolumeNameSize > 0) { lpVolumeNameBuffer[0] = 0; @@ -416,6 +422,7 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB } LONG WIN_FUNC CompareFileTime(const FILETIME *lpFileTime1, const FILETIME *lpFileTime2) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CompareFileTime(%p, %p)\n", lpFileTime1, lpFileTime2); auto toInt64 = [](const FILETIME *ft) -> int64_t { if (!ft) { @@ -437,6 +444,7 @@ LONG WIN_FUNC CompareFileTime(const FILETIME *lpFileTime1, const FILETIME *lpFil BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("WriteFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped); wibo::lastError = ERROR_SUCCESS; @@ -494,6 +502,7 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr } BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FlushFileBuffers(%p)\n", hFile); auto file = wibo::handles().getAs(hFile); if (!file || !file->valid()) { @@ -510,6 +519,7 @@ BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) { BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ReadFile(%p, %u)\n", hFile, nNumberOfBytesToRead); wibo::lastError = ERROR_SUCCESS; @@ -568,6 +578,7 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) { + WIN_API_SEGMENT_GUARD(); (void)hTemplateFile; if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -789,6 +800,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateFileW -> "); if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -800,6 +812,7 @@ HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS } BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) { + WIN_API_SEGMENT_GUARD(); if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; DEBUG_LOG("DeleteFileA(NULL) -> ERROR_INVALID_PARAMETER\n"); @@ -816,6 +829,7 @@ BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) { } BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DeleteFileW -> "); if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -826,6 +840,7 @@ BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) { } BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("MoveFileA(%s, %s)\n", lpExistingFileName ? lpExistingFileName : "(null)", lpNewFileName ? lpNewFileName : "(null)"); if (!lpExistingFileName || !lpNewFileName) { @@ -855,6 +870,7 @@ BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) { } BOOL WIN_FUNC MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("MoveFileW -> "); if (!lpExistingFileName || !lpNewFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -866,6 +882,7 @@ BOOL WIN_FUNC MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) { } DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetFilePointer(%p, %ld, %p, %u)\n", hFile, static_cast(lDistanceToMove), lpDistanceToMoveHigh, dwMoveMethod); if (hFile == nullptr) { @@ -907,6 +924,7 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod) { + WIN_API_SEGMENT_GUARD(); if (hFile == nullptr) { wibo::lastError = ERROR_INVALID_HANDLE; return FALSE; @@ -952,6 +970,7 @@ BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLA } BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetEndOfFile(%p)\n", hFile); HandleMeta meta{}; auto file = wibo::handles().getAs(hFile, &meta); @@ -974,6 +993,7 @@ BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) { } BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) { + WIN_API_SEGMENT_GUARD(); (void)lpSecurityAttributes; if (!lpPathName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -990,6 +1010,7 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri } BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) { + WIN_API_SEGMENT_GUARD(); if (!lpPathName) { wibo::lastError = ERROR_INVALID_PARAMETER; return FALSE; @@ -1005,6 +1026,7 @@ BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) { } BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) { + WIN_API_SEGMENT_GUARD(); (void)dwFileAttributes; if (!lpFileName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1016,6 +1038,7 @@ BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) { } DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileSize(%p, %p) ", hFile, lpFileSizeHigh); // TODO access check auto file = wibo::handles().getAs(hFile); @@ -1043,6 +1066,7 @@ DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) { BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileTime(%p, %p, %p, %p)\n", hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime); HandleMeta meta{}; auto file = wibo::handles().getAs(hFile, &meta); @@ -1085,6 +1109,7 @@ BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lp BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FILETIME *lpLastAccessTime, const FILETIME *lpLastWriteTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetFileTime(%p, %p, %p, %p)\n", hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime); HandleMeta meta{}; auto file = wibo::handles().getAs(hFile, &meta); @@ -1155,6 +1180,7 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI } BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileInformationByHandle(%p, %p)\n", hFile, lpFileInformation); if (!lpFileInformation) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1193,6 +1219,7 @@ BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMAT } DWORD WIN_FUNC GetFileType(HANDLE hFile) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileType(%p) ", hFile); auto file = wibo::handles().getAs(hFile); if (!file || !file->valid()) { @@ -1222,6 +1249,7 @@ DWORD WIN_FUNC GetFileType(HANDLE hFile) { } DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFullPathNameA(%s, %u)\n", lpFileName ? lpFileName : "(null)", nBufferLength); if (lpFilePart) { @@ -1274,6 +1302,7 @@ DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lp } DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFullPathNameW(%p, %u)\n", lpFileName, nBufferLength); if (lpFilePart) { @@ -1327,6 +1356,7 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR } DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetShortPathNameA(%s)\n", lpszLongPath ? lpszLongPath : "(null)"); if (!lpszLongPath || !lpszShortPath) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1347,6 +1377,7 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD } DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer) { + WIN_API_SEGMENT_GUARD(); if (!lpszLongPath || !lpszShortPath) { wibo::lastError = ERROR_INVALID_PARAMETER; return 0; @@ -1368,6 +1399,7 @@ DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWO } UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetTempFileNameA(%s, %s, %u)\n", lpPathName ? lpPathName : "(null)", lpPrefixString ? lpPrefixString : "(null)", uUnique); if (!lpPathName || !lpPrefixString || !lpTempFileName) { @@ -1410,6 +1442,7 @@ UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uU } DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetTempPathA(%u, %p)\n", nBufferLength, lpBuffer); if (nBufferLength == 0 || lpBuffer == nullptr) { @@ -1437,6 +1470,7 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) { } HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindFirstFileA(%s, %p)", lpFileName ? lpFileName : "(null)", lpFindFileData); if (!lpFileName || !lpFindFileData) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1479,6 +1513,7 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD } HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindFirstFileW(%p, %p)", lpFileName, lpFindFileData); if (!lpFileName || !lpFindFileData) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1523,6 +1558,7 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile HANDLE WIN_FUNC FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindFirstFileExA(%s, %d, %p, %d, %p, 0x%x) -> ", lpFileName ? lpFileName : "(null)", fInfoLevelId, lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags); (void)fInfoLevelId; @@ -1533,6 +1569,7 @@ HANDLE WIN_FUNC FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLeve } BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindNextFileA(%p, %p)\n", hFindFile, lpFindFileData); if (!lpFindFileData) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1561,6 +1598,7 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) } BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindNextFileW(%p, %p)\n", hFindFile, lpFindFileData); if (!lpFindFileData) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1589,6 +1627,7 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) } BOOL WIN_FUNC FindClose(HANDLE hFindFile) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindClose(%p)\n", hFindFile); if (isPseudoHandle(hFindFile) || hFindFile == nullptr) { wibo::lastError = ERROR_SUCCESS; diff --git a/dll/kernel32/handleapi.cpp b/dll/kernel32/handleapi.cpp index f00d424..5373ef2 100644 --- a/dll/kernel32/handleapi.cpp +++ b/dll/kernel32/handleapi.cpp @@ -11,6 +11,7 @@ namespace kernel32 { BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DuplicateHandle(%p, %p, %p, %p, %x, %d, %x)\n", hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions); (void)dwDesiredAccess; @@ -62,6 +63,7 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, } BOOL WIN_FUNC CloseHandle(HANDLE hObject) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CloseHandle(%p)\n", hObject); if (!wibo::handles().release(hObject)) { wibo::lastError = ERROR_INVALID_HANDLE; diff --git a/dll/kernel32/heapapi.cpp b/dll/kernel32/heapapi.cpp index 24e02b3..b6dd9a1 100644 --- a/dll/kernel32/heapapi.cpp +++ b/dll/kernel32/heapapi.cpp @@ -76,6 +76,7 @@ HeapObject::~HeapObject() { namespace kernel32 { HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapCreate(%u, %zu, %zu)\n", flOptions, dwInitialSize, dwMaximumSize); if (dwMaximumSize != 0 && dwInitialSize > dwMaximumSize) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -101,6 +102,7 @@ HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaxim } BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapDestroy(%p)\n", hHeap); auto record = wibo::handles().getAs(hHeap); if (!record) { @@ -119,6 +121,7 @@ BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) { } HANDLE WIN_FUNC GetProcessHeap() { + WIN_API_SEGMENT_GUARD(); ensureProcessHeapInitialized(); wibo::lastError = ERROR_SUCCESS; DEBUG_LOG("GetProcessHeap() -> %p\n", g_processHeapHandle); @@ -127,6 +130,7 @@ HANDLE WIN_FUNC GetProcessHeap() { BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapSetInformation(%p, %d, %p, %zu)\n", HeapHandle, static_cast(HeapInformationClass), HeapInformation, HeapInformationLength); auto record = wibo::handles().getAs(HeapHandle); @@ -162,6 +166,7 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI } LPVOID WIN_FUNC HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapAlloc(%p, 0x%x, %zu) ", hHeap, dwFlags, dwBytes); auto record = wibo::handles().getAs(hHeap); if (!record) { @@ -181,6 +186,7 @@ LPVOID WIN_FUNC HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) { } LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapReAlloc(%p, 0x%x, %p, %zu) ", hHeap, dwFlags, lpMem, dwBytes); auto record = wibo::handles().getAs(hHeap); if (!record) { @@ -258,6 +264,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw } SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapSize(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem); (void)dwFlags; auto record = wibo::handles().getAs(hHeap); @@ -274,16 +281,18 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) { wibo::lastError = ERROR_INVALID_PARAMETER; return static_cast(-1); } - // if (!mi_heap_check_owned(record->heap, const_cast(lpMem))) { - // wibo::lastError = ERROR_INVALID_PARAMETER; - // return static_cast(-1); - // } + if (!mi_heap_check_owned(record->heap, const_cast(lpMem))) { + DEBUG_LOG("HeapSize: block %p not owned by heap %p\n", lpMem, record->heap); + wibo::lastError = ERROR_INVALID_PARAMETER; + return static_cast(-1); + } size_t size = mi_usable_size(lpMem); wibo::lastError = ERROR_SUCCESS; return static_cast(size); } BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("HeapFree(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem); (void)dwFlags; if (lpMem == nullptr) { @@ -302,10 +311,11 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) { wibo::lastError = ERROR_INVALID_PARAMETER; return FALSE; } - // if (!mi_heap_check_owned(record->heap, lpMem)) { - // wibo::lastError = ERROR_INVALID_PARAMETER; - // return FALSE; - // } + if (!mi_heap_check_owned(record->heap, lpMem)) { + DEBUG_LOG("HeapFree: block %p not owned by heap %p\n", lpMem, record->heap); + wibo::lastError = ERROR_INVALID_PARAMETER; + return FALSE; + } mi_free(lpMem); DEBUG_LOG("-> SUCCESS\n"); wibo::lastError = ERROR_SUCCESS; diff --git a/dll/kernel32/interlockedapi.cpp b/dll/kernel32/interlockedapi.cpp index 8ff7b57..87d3c2c 100644 --- a/dll/kernel32/interlockedapi.cpp +++ b/dll/kernel32/interlockedapi.cpp @@ -6,16 +6,19 @@ namespace kernel32 { LONG WIN_FUNC InterlockedIncrement(LONG volatile *Addend) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("InterlockedIncrement(%p)\n", Addend); return ++(*Addend); } LONG WIN_FUNC InterlockedDecrement(LONG volatile *Addend) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("InterlockedDecrement(%p)\n", Addend); return --(*Addend); } LONG WIN_FUNC InterlockedExchange(LONG volatile *Target, LONG Value) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("InterlockedExchange(%p, %ld)\n", Target, static_cast(Value)); LONG initial = *Target; *Target = Value; @@ -23,6 +26,7 @@ LONG WIN_FUNC InterlockedExchange(LONG volatile *Target, LONG Value) { } LONG WIN_FUNC InterlockedCompareExchange(LONG volatile *Destination, LONG Exchange, LONG Comperand) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("InterlockedCompareExchange(%p, %ld, %ld)\n", Destination, static_cast(Exchange), static_cast(Comperand)); LONG original = *Destination; @@ -33,6 +37,7 @@ LONG WIN_FUNC InterlockedCompareExchange(LONG volatile *Destination, LONG Exchan } void WIN_FUNC InitializeSListHead(PSLIST_HEADER ListHead) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("InitializeSListHead(%p)\n", ListHead); if (!ListHead) { return; diff --git a/dll/kernel32/ioapiset.cpp b/dll/kernel32/ioapiset.cpp index db634af..fba512b 100644 --- a/dll/kernel32/ioapiset.cpp +++ b/dll/kernel32/ioapiset.cpp @@ -7,6 +7,7 @@ namespace kernel32 { BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetOverlappedResult(%p, %p, %p, %d)\n", hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait); (void)hFile; if (!lpOverlapped) { diff --git a/dll/kernel32/libloaderapi.cpp b/dll/kernel32/libloaderapi.cpp index c24f5e8..08ac3fc 100644 --- a/dll/kernel32/libloaderapi.cpp +++ b/dll/kernel32/libloaderapi.cpp @@ -31,6 +31,7 @@ HRSRC findResourceInternal(HMODULE hModule, const wibo::ResourceIdentifier &type namespace kernel32 { BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DisableThreadLibraryCalls(%p)\n", hLibModule); if (!hLibModule) { wibo::lastError = ERROR_INVALID_HANDLE; @@ -50,6 +51,7 @@ BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) { } HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetModuleHandleA(%s)\n", lpModuleName); const auto *module = wibo::findLoadedModule(lpModuleName); if (!module) { @@ -61,6 +63,7 @@ HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) { } HMODULE WIN_FUNC GetModuleHandleW(LPCWSTR lpModuleName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetModuleHandleW -> "); if (lpModuleName) { const auto lpModuleNameA = wideStringToString(lpModuleName); @@ -70,6 +73,7 @@ HMODULE WIN_FUNC GetModuleHandleW(LPCWSTR lpModuleName) { } DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetModuleFileNameA(%p, %p, %u)\n", hModule, lpFilename, nSize); if (!lpFilename) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -106,6 +110,7 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize } DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetModuleFileNameW(%p, %s, %u)\n", hModule, wideStringToString(lpFilename).c_str(), nSize); if (!lpFilename) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -147,6 +152,7 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz } HRSRC WIN_FUNC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindResourceA %p %p %p\n", hModule, lpName, lpType); auto type = wibo::resourceIdentifierFromAnsi(lpType); auto name = wibo::resourceIdentifierFromAnsi(lpName); @@ -154,6 +160,7 @@ HRSRC WIN_FUNC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType) { } HRSRC WIN_FUNC FindResourceExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindResourceExA %p %p %p %u\n", hModule, lpName, lpType, wLanguage); auto type = wibo::resourceIdentifierFromAnsi(lpType); auto name = wibo::resourceIdentifierFromAnsi(lpName); @@ -161,6 +168,7 @@ HRSRC WIN_FUNC FindResourceExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WO } HRSRC WIN_FUNC FindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindResourceW %p\n", hModule); auto type = wibo::resourceIdentifierFromWide(lpType); auto name = wibo::resourceIdentifierFromWide(lpName); @@ -168,6 +176,7 @@ HRSRC WIN_FUNC FindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType) { } HRSRC WIN_FUNC FindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FindResourceExW %p %u\n", hModule, wLanguage); auto type = wibo::resourceIdentifierFromWide(lpType); auto name = wibo::resourceIdentifierFromWide(lpName); @@ -175,6 +184,7 @@ HRSRC WIN_FUNC FindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, } HGLOBAL WIN_FUNC LoadResource(HMODULE hModule, HRSRC hResInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LoadResource %p %p\n", hModule, hResInfo); if (!hResInfo) { wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND; @@ -194,11 +204,13 @@ HGLOBAL WIN_FUNC LoadResource(HMODULE hModule, HRSRC hResInfo) { } LPVOID WIN_FUNC LockResource(HGLOBAL hResData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LockResource(%p)\n", hResData); return hResData; } DWORD WIN_FUNC SizeofResource(HMODULE hModule, HRSRC hResInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SizeofResource(%p, %p)\n", hModule, hResInfo); if (!hResInfo) { wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND; @@ -218,6 +230,7 @@ DWORD WIN_FUNC SizeofResource(HMODULE hModule, HRSRC hResInfo) { } HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LoadLibraryA(%s)\n", lpLibFileName); const auto *info = wibo::loadModule(lpLibFileName); if (!info) { @@ -229,6 +242,7 @@ HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) { } HMODULE WIN_FUNC LoadLibraryW(LPCWSTR lpLibFileName) { + WIN_API_SEGMENT_GUARD(); if (!lpLibFileName) { return nullptr; } @@ -238,6 +252,7 @@ HMODULE WIN_FUNC LoadLibraryW(LPCWSTR lpLibFileName) { } HMODULE WIN_FUNC LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); assert(!hFile); DEBUG_LOG("LoadLibraryExW(%x) -> ", dwFlags); auto filename = wideStringToString(lpLibFileName); @@ -245,6 +260,7 @@ HMODULE WIN_FUNC LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFla } BOOL WIN_FUNC FreeLibrary(HMODULE hLibModule) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FreeLibrary(%p)\n", hLibModule); auto *info = wibo::moduleInfoFromHandle(hLibModule); if (!info) { @@ -256,6 +272,7 @@ BOOL WIN_FUNC FreeLibrary(HMODULE hLibModule) { } FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) { + WIN_API_SEGMENT_GUARD(); FARPROC result; const auto info = wibo::moduleInfoFromHandle(hModule); if (!info) { diff --git a/dll/kernel32/memoryapi.cpp b/dll/kernel32/memoryapi.cpp index bfd136c..77dec68 100644 --- a/dll/kernel32/memoryapi.cpp +++ b/dll/kernel32/memoryapi.cpp @@ -462,6 +462,7 @@ namespace kernel32 { HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateFileMappingA(%p, %p, %u, %u, %u, %s)\n", hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName ? lpName : "(null)"); (void)lpFileMappingAttributes; @@ -513,6 +514,7 @@ HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap HANDLE WIN_FUNC CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateFileMappingW -> "); std::string name = wideStringToString(lpName); return CreateFileMappingA(hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, @@ -659,6 +661,7 @@ static LPVOID mapViewOfFileInternal(Pin mapping, DWORD dwDesiredA LPVOID WIN_FUNC MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("MapViewOfFile(%p, 0x%x, %u, %u, %zu)\n", hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap); @@ -673,6 +676,7 @@ LPVOID WIN_FUNC MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, LPVOID WIN_FUNC MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("MapViewOfFileEx(%p, 0x%x, %u, %u, %zu, %p)\n", hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap, lpBaseAddress); @@ -686,6 +690,7 @@ LPVOID WIN_FUNC MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess } BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("UnmapViewOfFile(%p)\n", lpBaseAddress); std::unique_lock lk(g_viewInfoMutex); auto it = g_viewInfo.find(reinterpret_cast(lpBaseAddress)); @@ -705,6 +710,7 @@ BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) { } LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("VirtualAlloc(%p, %zu, %u, %u)\n", lpAddress, dwSize, flAllocationType, flProtect); if (dwSize == 0) { @@ -894,6 +900,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation } BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("VirtualFree(%p, %zu, %u)\n", lpAddress, dwSize, dwFreeType); if (!lpAddress) { wibo::lastError = ERROR_INVALID_ADDRESS; @@ -986,6 +993,7 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) { } BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("VirtualProtect(%p, %zu, %u)\n", lpAddress, dwSize, flNewProtect); if (!lpAddress || dwSize == 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1045,6 +1053,7 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect } SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("VirtualQuery(%p, %p, %zu)\n", lpAddress, lpBuffer, dwLength); if (!lpBuffer || dwLength < sizeof(MEMORY_BASIC_INFORMATION)) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -1086,6 +1095,7 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize, PSIZE_T lpMaximumWorkingSetSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetProcessWorkingSetSize(%p, %p, %p)\n", hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize); (void)hProcess; if (!lpMinimumWorkingSetSize || !lpMaximumWorkingSetSize) { @@ -1100,6 +1110,7 @@ BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorking BOOL WIN_FUNC SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize, SIZE_T dwMaximumWorkingSetSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetProcessWorkingSetSize(%p, %zu, %zu)\n", hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize); (void)hProcess; (void)dwMinimumWorkingSetSize; diff --git a/dll/kernel32/namedpipeapi.cpp b/dll/kernel32/namedpipeapi.cpp index 818a5af..604dfad 100644 --- a/dll/kernel32/namedpipeapi.cpp +++ b/dll/kernel32/namedpipeapi.cpp @@ -35,6 +35,7 @@ void configureInheritability(int fd, bool inherit) { } // namespace BOOL WIN_FUNC CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreatePipe(%p, %p, %p, %u)\n", hReadPipe, hWritePipe, lpPipeAttributes, nSize); if (!hReadPipe || !hWritePipe) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/processenv.cpp b/dll/kernel32/processenv.cpp index 95fdf6f..ea324ed 100644 --- a/dll/kernel32/processenv.cpp +++ b/dll/kernel32/processenv.cpp @@ -41,28 +41,33 @@ std::string convertEnvValueToHost(const std::string &name, const char *rawValue) namespace kernel32 { LPSTR WIN_FUNC GetCommandLineA() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCommandLineA() -> %s\n", wibo::commandLine.c_str()); wibo::lastError = ERROR_SUCCESS; return const_cast(wibo::commandLine.c_str()); } LPWSTR WIN_FUNC GetCommandLineW() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCommandLineW() -> %s\n", wideStringToString(wibo::commandLineW.data()).c_str()); wibo::lastError = ERROR_SUCCESS; return wibo::commandLineW.data(); } HANDLE WIN_FUNC GetStdHandle(DWORD nStdHandle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetStdHandle(%d)\n", nStdHandle); return files::getStdHandle(nStdHandle); } BOOL WIN_FUNC SetStdHandle(DWORD nStdHandle, HANDLE hHandle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetStdHandle(%d, %p)\n", nStdHandle, hHandle); return files::setStdHandle(nStdHandle, hHandle); } LPCH WIN_FUNC GetEnvironmentStrings() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetEnvironmentStrings()\n"); size_t bufSize = 0; @@ -96,6 +101,7 @@ LPCH WIN_FUNC GetEnvironmentStrings() { } LPWCH WIN_FUNC GetEnvironmentStringsW() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetEnvironmentStringsW()\n"); size_t bufSizeW = 0; @@ -131,6 +137,7 @@ LPWCH WIN_FUNC GetEnvironmentStringsW() { } BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FreeEnvironmentStringsA(%p)\n", penv); if (!penv) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -142,6 +149,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) { } BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FreeEnvironmentStringsW(%p)\n", penv); if (!penv) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -153,6 +161,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) { } DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetEnvironmentVariableA(%s, %p, %u)\n", lpName ? lpName : "(null)", lpBuffer, nSize); if (!lpName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -184,6 +193,7 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz } DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); std::string name = lpName ? wideStringToString(lpName) : std::string(); DEBUG_LOG("GetEnvironmentVariableW(%s, %p, %u)\n", name.c_str(), lpBuffer, nSize); if (name.empty()) { @@ -217,6 +227,7 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS } BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetEnvironmentVariableA(%s, %s)\n", lpName ? lpName : "(null)", lpValue ? lpValue : "(null)"); if (!lpName || std::strchr(lpName, '=')) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -244,6 +255,7 @@ BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) { } BOOL WIN_FUNC SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetEnvironmentVariableW -> "); if (!lpName) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/processthreadsapi.cpp b/dll/kernel32/processthreadsapi.cpp index f179160..1453a01 100644 --- a/dll/kernel32/processthreadsapi.cpp +++ b/dll/kernel32/processthreadsapi.cpp @@ -124,14 +124,19 @@ void *threadTrampoline(void *param) { // Install TIB TIB *threadTib = nullptr; - uint16_t previousSegment = 0; + uint16_t previousFs = 0; + uint16_t previousGs = 0; if (wibo::tibSelector) { - asm volatile("mov %%fs, %0" : "=r"(previousSegment)); + asm volatile("mov %%fs, %0" : "=r"(previousFs)); + asm volatile("mov %%gs, %0" : "=r"(previousGs)); threadTib = wibo::allocateTib(); if (threadTib) { wibo::initializeTibStackInfo(threadTib); if (wibo::installTibForCurrentThread(threadTib)) { asm volatile("movw %0, %%fs" : : "r"(wibo::tibSelector) : "memory"); + threadTib->hostFsSelector = previousFs; + threadTib->hostGsSelector = previousGs; + threadTib->hostSegmentsValid = 1; } else { fprintf(stderr, "!!! Failed to install TIB for new thread\n"); wibo::destroyTib(threadTib); @@ -172,6 +177,7 @@ inline bool isPseudoCurrentThreadHandle(HANDLE h) { namespace kernel32 { BOOL WIN_FUNC IsProcessorFeaturePresent(DWORD ProcessorFeature) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsProcessorFeaturePresent(%u)\n", ProcessorFeature); if (ProcessorFeature == 0) { // PF_FLOATING_POINT_PRECISION_ERRATA return TRUE; @@ -187,17 +193,20 @@ BOOL WIN_FUNC IsProcessorFeaturePresent(DWORD ProcessorFeature) { } HANDLE WIN_FUNC GetCurrentProcess() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCurrentProcess() -> %p\n", reinterpret_cast(static_cast(-1))); return reinterpret_cast(static_cast(-1)); } DWORD WIN_FUNC GetCurrentProcessId() { + WIN_API_SEGMENT_GUARD(); DWORD pid = static_cast(getpid()); DEBUG_LOG("GetCurrentProcessId() -> %u\n", pid); return pid; } DWORD WIN_FUNC GetCurrentThreadId() { + WIN_API_SEGMENT_GUARD(); pthread_t thread = pthread_self(); const auto threadId = static_cast(thread); DEBUG_LOG("GetCurrentThreadId() -> %u\n", threadId); @@ -205,6 +214,7 @@ DWORD WIN_FUNC GetCurrentThreadId() { } HANDLE WIN_FUNC GetCurrentThread() { + WIN_API_SEGMENT_GUARD(); HANDLE pseudoHandle = reinterpret_cast(kPseudoCurrentThreadHandleValue); DEBUG_LOG("GetCurrentThread() -> %p\n", pseudoHandle); return pseudoHandle; @@ -212,6 +222,7 @@ HANDLE WIN_FUNC GetCurrentThread() { BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask, PDWORD_PTR lpSystemAffinityMask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetProcessAffinityMask(%p, %p, %p)\n", hProcess, lpProcessAffinityMask, lpSystemAffinityMask); if (!lpProcessAffinityMask || !lpSystemAffinityMask) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -245,6 +256,7 @@ BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffini } BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinityMask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetProcessAffinityMask(%p, 0x%lx)\n", hProcess, static_cast(dwProcessAffinityMask)); if (dwProcessAffinityMask == 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -274,6 +286,7 @@ BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinit } DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetThreadAffinityMask(%p, 0x%lx)\n", hThread, static_cast(dwThreadAffinityMask)); if (dwThreadAffinityMask == 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -303,11 +316,13 @@ DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffin } void WIN_FUNC ExitProcess(UINT uExitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ExitProcess(%u)\n", uExitCode); exit(static_cast(uExitCode)); } BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("TerminateProcess(%p, %u)\n", hProcess, uExitCode); if (hProcess == reinterpret_cast(static_cast(-1))) { exit(static_cast(uExitCode)); @@ -343,6 +358,7 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) { } BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetExitCodeProcess(%p, %p)\n", hProcess, lpExitCode); if (!lpExitCode) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -364,6 +380,7 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) { } DWORD WIN_FUNC TlsAlloc() { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("TlsAlloc()\n"); for (DWORD i = 0; i < kMaxTlsValues; ++i) { if (!g_tlsSlotsUsed[i]) { @@ -378,6 +395,7 @@ DWORD WIN_FUNC TlsAlloc() { } BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("TlsFree(%u)\n", dwTlsIndex); if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -390,6 +408,7 @@ BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) { } LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("TlsGetValue(%u)\n", dwTlsIndex); if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -400,6 +419,7 @@ LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) { } BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("TlsSetValue(%u, %p)\n", dwTlsIndex, lpTlsValue); if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -411,6 +431,7 @@ BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) { } DWORD WIN_FUNC ResumeThread(HANDLE hThread) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ResumeThread(%p)\n", hThread); // TODO: behavior with current thread handle? auto obj = wibo::handles().getAs(hThread); @@ -438,6 +459,7 @@ DWORD WIN_FUNC ResumeThread(HANDLE hThread) { } HRESULT WIN_FUNC SetThreadDescription(HANDLE hThread, LPCWSTR lpThreadDescription) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetThreadDescription(%p, %p)\n", hThread, lpThreadDescription); (void)hThread; (void)lpThreadDescription; @@ -447,6 +469,7 @@ HRESULT WIN_FUNC SetThreadDescription(HANDLE hThread, LPCWSTR lpThreadDescriptio HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateThread(%p, %zu, %p, %p, %u, %p)\n", lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId); (void)lpThreadAttributes; @@ -494,6 +517,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw } [[noreturn]] void WIN_FUNC ExitThread(DWORD dwExitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ExitThread(%u)\n", dwExitCode); ThreadObject *obj = g_currentThreadObject; { @@ -507,6 +531,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw } BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetExitCodeThread(%p, %p)\n", hThread, lpExitCode); if (!lpExitCode) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -529,6 +554,7 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) { } BOOL WIN_FUNC SetThreadPriority(HANDLE hThread, int nPriority) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetThreadPriority(%p, %d)\n", hThread, nPriority); (void)hThread; (void)nPriority; @@ -537,6 +563,7 @@ BOOL WIN_FUNC SetThreadPriority(HANDLE hThread, int nPriority) { } int WIN_FUNC GetThreadPriority(HANDLE hThread) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetThreadPriority(%p)\n", hThread); (void)hThread; wibo::lastError = ERROR_SUCCESS; @@ -544,6 +571,7 @@ int WIN_FUNC GetThreadPriority(HANDLE hThread) { } DWORD WIN_FUNC GetPriorityClass(HANDLE hProcess) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetPriorityClass(%p)\n", hProcess); (void)hProcess; wibo::lastError = ERROR_SUCCESS; @@ -552,6 +580,7 @@ DWORD WIN_FUNC GetPriorityClass(HANDLE hProcess) { BOOL WIN_FUNC GetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime, FILETIME *lpExitTime, FILETIME *lpKernelTime, FILETIME *lpUserTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetThreadTimes(%p, %p, %p, %p, %p)\n", hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime); if (!lpKernelTime || !lpUserTime) { @@ -601,6 +630,7 @@ BOOL WIN_FUNC CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSE LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateProcessA %s \"%s\" %p %p %d 0x%x %p %s %p %p\n", lpApplicationName ? lpApplicationName : "", lpCommandLine ? lpCommandLine : "", lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory ? lpCurrentDirectory : "", lpStartupInfo, @@ -655,6 +685,7 @@ BOOL WIN_FUNC CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LP LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation) { + WIN_API_SEGMENT_GUARD(); std::string applicationUtf8; if (lpApplicationName) { applicationUtf8 = wideStringToString(lpApplicationName); @@ -686,16 +717,19 @@ BOOL WIN_FUNC CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LP } void WIN_FUNC GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetStartupInfoA(%p)\n", lpStartupInfo); populateStartupInfo(lpStartupInfo); } void WIN_FUNC GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetStartupInfoW(%p)\n", lpStartupInfo); populateStartupInfo(lpStartupInfo); } BOOL WIN_FUNC SetThreadStackGuarantee(PULONG StackSizeInBytes) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetThreadStackGuarantee(%p)\n", StackSizeInBytes); (void)StackSizeInBytes; return TRUE; diff --git a/dll/kernel32/profileapi.cpp b/dll/kernel32/profileapi.cpp index ceaaf84..0265ba5 100644 --- a/dll/kernel32/profileapi.cpp +++ b/dll/kernel32/profileapi.cpp @@ -5,6 +5,7 @@ namespace kernel32 { BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: QueryPerformanceCounter(%p)\n", lpPerformanceCount); if (!lpPerformanceCount) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -16,6 +17,7 @@ BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) { } BOOL WIN_FUNC QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: QueryPerformanceFrequency(%p)\n", lpFrequency); if (!lpFrequency) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/stringapiset.cpp b/dll/kernel32/stringapiset.cpp index bf1ead2..feb3d5e 100644 --- a/dll/kernel32/stringapiset.cpp +++ b/dll/kernel32/stringapiset.cpp @@ -12,6 +12,7 @@ namespace kernel32 { int WIN_FUNC WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, LPCCH lpDefaultChar, LPBOOL lpUsedDefaultChar) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("WideCharToMultiByte(%u, %u, %p, %d, %p, %d, %p, %p)\n", CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar); @@ -43,6 +44,7 @@ int WIN_FUNC WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideChar int WIN_FUNC MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("MultiByteToWideChar(%u, %u, %d, %d)\n", CodePage, dwFlags, cbMultiByte, cchWideChar); (void)CodePage; @@ -68,6 +70,7 @@ int WIN_FUNC MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByte } BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetStringTypeW(%u, %p, %i, %p)\n", dwInfoType, lpSrcStr, cchSrc, lpCharType); assert(dwInfoType == 1); // CT_CTYPE1 @@ -101,6 +104,7 @@ BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWO } BOOL WIN_FUNC GetStringTypeA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetStringTypeA(%u, %u, %p, %d, %p)\n", Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType); (void)Locale; diff --git a/dll/kernel32/synchapi.cpp b/dll/kernel32/synchapi.cpp index e35b9f5..be5dfff 100644 --- a/dll/kernel32/synchapi.cpp +++ b/dll/kernel32/synchapi.cpp @@ -38,11 +38,13 @@ void makeWideNameFromAnsi(LPCSTR ansiName, std::vector &outWide) { namespace kernel32 { void WIN_FUNC Sleep(DWORD dwMilliseconds) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("Sleep(%u)\n", dwMilliseconds); usleep(static_cast(dwMilliseconds) * 1000); } HANDLE WIN_FUNC CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateMutexW(%p, %d, %s)\n", lpMutexAttributes, static_cast(bInitialOwner), wideStringToString(lpName).c_str()); std::u16string name = makeU16String(lpName); @@ -73,6 +75,7 @@ HANDLE WIN_FUNC CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInit } HANDLE WIN_FUNC CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateMutexA -> "); std::vector wideName; makeWideNameFromAnsi(lpName, wideName); @@ -81,6 +84,7 @@ HANDLE WIN_FUNC CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInit } BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ReleaseMutex(%p)\n", hMutex); auto mu = wibo::handles().getAs(hMutex); if (!mu) { @@ -110,6 +114,7 @@ BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) { HANDLE WIN_FUNC CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateEventW(%p, %d, %d, %s)\n", lpEventAttributes, static_cast(bManualReset), static_cast(bInitialState), wideStringToString(lpName).c_str()); std::u16string name = makeU16String(lpName); @@ -136,6 +141,7 @@ HANDLE WIN_FUNC CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManu HANDLE WIN_FUNC CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateEventA -> "); std::vector wideName; makeWideNameFromAnsi(lpName, wideName); @@ -145,6 +151,7 @@ HANDLE WIN_FUNC CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManu HANDLE WIN_FUNC CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateSemaphoreW(%p, %ld, %ld, %s)\n", lpSemaphoreAttributes, lInitialCount, lMaximumCount, wideStringToString(lpName).c_str()); auto name = makeU16String(lpName); @@ -171,6 +178,7 @@ HANDLE WIN_FUNC CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LO HANDLE WIN_FUNC CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CreateSemaphoreA -> "); std::vector wideName; makeWideNameFromAnsi(lpName, wideName); @@ -179,6 +187,7 @@ HANDLE WIN_FUNC CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LO } BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPreviousCount) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ReleaseSemaphore(%p, %ld, %p)\n", hSemaphore, lReleaseCount, lpPreviousCount); if (lReleaseCount <= 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -215,6 +224,7 @@ BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPr } BOOL WIN_FUNC SetEvent(HANDLE hEvent) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetEvent(%p)\n", hEvent); auto ev = wibo::handles().getAs(hEvent); if (!ev) { @@ -227,6 +237,7 @@ BOOL WIN_FUNC SetEvent(HANDLE hEvent) { } BOOL WIN_FUNC ResetEvent(HANDLE hEvent) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("ResetEvent(%p)\n", hEvent); auto ev = wibo::handles().getAs(hEvent); if (!ev) { @@ -239,6 +250,7 @@ BOOL WIN_FUNC ResetEvent(HANDLE hEvent) { } DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("WaitForSingleObject(%p, %u)\n", hHandle, dwMilliseconds); HandleMeta meta{}; Pin<> obj = wibo::handles().get(hHandle, &meta); @@ -346,6 +358,7 @@ DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) { } void WIN_FUNC InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: InitializeCriticalSection(%p)\n", lpCriticalSection); if (!lpCriticalSection) { return; @@ -354,6 +367,7 @@ void WIN_FUNC InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection) { } BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount, DWORD Flags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: InitializeCriticalSectionEx(%p, %u, 0x%x)\n", lpCriticalSection, dwSpinCount, Flags); if (!lpCriticalSection) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -370,6 +384,7 @@ BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, } BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: InitializeCriticalSectionAndSpinCount(%p, %u)\n", lpCriticalSection, dwSpinCount); if (!lpCriticalSection) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -382,21 +397,25 @@ BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCritica } void WIN_FUNC DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: DeleteCriticalSection(%p)\n", lpCriticalSection); (void)lpCriticalSection; } void WIN_FUNC EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: EnterCriticalSection(%p)\n", lpCriticalSection); (void)lpCriticalSection; } void WIN_FUNC LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: LeaveCriticalSection(%p)\n", lpCriticalSection); (void)lpCriticalSection; } BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBOOL fPending, LPVOID *lpContext) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: InitOnceBeginInitialize(%p, %u, %p, %p)\n", lpInitOnce, dwFlags, fPending, lpContext); if (!lpInitOnce) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -417,6 +436,7 @@ BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBO } BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: InitOnceComplete(%p, %u, %p)\n", lpInitOnce, dwFlags, lpContext); if (!lpInitOnce) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -431,15 +451,28 @@ BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpC return TRUE; } -void WIN_FUNC AcquireSRWLockShared(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: AcquireSRWLockShared(%p)\n", SRWLock); } +void WIN_FUNC AcquireSRWLockShared(PSRWLOCK SRWLock) { + WIN_API_SEGMENT_GUARD(); + VERBOSE_LOG("STUB: AcquireSRWLockShared(%p)\n", SRWLock); +} -void WIN_FUNC ReleaseSRWLockShared(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: ReleaseSRWLockShared(%p)\n", SRWLock); } +void WIN_FUNC ReleaseSRWLockShared(PSRWLOCK SRWLock) { + WIN_API_SEGMENT_GUARD(); + VERBOSE_LOG("STUB: ReleaseSRWLockShared(%p)\n", SRWLock); +} -void WIN_FUNC AcquireSRWLockExclusive(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: AcquireSRWLockExclusive(%p)\n", SRWLock); } +void WIN_FUNC AcquireSRWLockExclusive(PSRWLOCK SRWLock) { + WIN_API_SEGMENT_GUARD(); + VERBOSE_LOG("STUB: AcquireSRWLockExclusive(%p)\n", SRWLock); +} -void WIN_FUNC ReleaseSRWLockExclusive(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: ReleaseSRWLockExclusive(%p)\n", SRWLock); } +void WIN_FUNC ReleaseSRWLockExclusive(PSRWLOCK SRWLock) { + WIN_API_SEGMENT_GUARD(); + VERBOSE_LOG("STUB: ReleaseSRWLockExclusive(%p)\n", SRWLock); +} BOOLEAN WIN_FUNC TryAcquireSRWLockExclusive(PSRWLOCK SRWLock) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("STUB: TryAcquireSRWLockExclusive(%p)\n", SRWLock); return TRUE; } diff --git a/dll/kernel32/sysinfoapi.cpp b/dll/kernel32/sysinfoapi.cpp index 2ffcb2f..c5f086d 100644 --- a/dll/kernel32/sysinfoapi.cpp +++ b/dll/kernel32/sysinfoapi.cpp @@ -31,6 +31,7 @@ DWORD_PTR computeSystemProcessorMask(unsigned int cpuCount) { namespace kernel32 { void WIN_FUNC GetSystemInfo(LPSYSTEM_INFO lpSystemInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemInfo(%p)\n", lpSystemInfo); if (!lpSystemInfo) { return; @@ -67,6 +68,7 @@ void WIN_FUNC GetSystemInfo(LPSYSTEM_INFO lpSystemInfo) { } void WIN_FUNC GetSystemTime(LPSYSTEMTIME lpSystemTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemTime(%p)\n", lpSystemTime); if (!lpSystemTime) { return; @@ -95,6 +97,7 @@ void WIN_FUNC GetSystemTime(LPSYSTEMTIME lpSystemTime) { } void WIN_FUNC GetLocalTime(LPSYSTEMTIME lpSystemTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLocalTime(%p)\n", lpSystemTime); if (!lpSystemTime) { return; @@ -123,6 +126,7 @@ void WIN_FUNC GetLocalTime(LPSYSTEMTIME lpSystemTime) { } void WIN_FUNC GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemTimeAsFileTime(%p)\n", lpSystemTimeAsFileTime); if (!lpSystemTimeAsFileTime) { return; @@ -154,6 +158,7 @@ void WIN_FUNC GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime) { } DWORD WIN_FUNC GetTickCount() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetTickCount()\n"); #if defined(CLOCK_MONOTONIC) struct timespec ts{}; @@ -178,11 +183,13 @@ DWORD WIN_FUNC GetTickCount() { } DWORD WIN_FUNC GetVersion() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetVersion()\n"); return kMajorVersion | (kMinorVersion << 8) | (5 << 16) | (kBuildNumber << 24); } BOOL WIN_FUNC GetVersionExA(LPOSVERSIONINFOA lpVersionInformation) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetVersionExA(%p)\n", lpVersionInformation); if (!lpVersionInformation) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/timezoneapi.cpp b/dll/kernel32/timezoneapi.cpp index 4575ddc..e7d6f28 100644 --- a/dll/kernel32/timezoneapi.cpp +++ b/dll/kernel32/timezoneapi.cpp @@ -10,6 +10,7 @@ namespace kernel32 { BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SystemTimeToFileTime(%p, %p)\n", lpSystemTime, lpFileTime); if (!lpSystemTime || !lpFileTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -36,6 +37,7 @@ BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lp } BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FileTimeToSystemTime(%p, %p)\n", lpFileTime, lpSystemTime); if (!lpFileTime || !lpSystemTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -65,6 +67,7 @@ BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSy } BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpLocalFileTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FileTimeToLocalFileTime(%p, %p)\n", lpFileTime, lpLocalFileTime); if (!lpFileTime || !lpLocalFileTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -114,6 +117,7 @@ BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpL } BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIME lpFileTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LocalFileTimeToFileTime(%p, %p)\n", lpLocalFileTime, lpFileTime); if (!lpLocalFileTime || !lpFileTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -156,6 +160,7 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM } BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DosDateTimeToFileTime(%04x, %04x, %p)\n", wFatDate, wFatTime, lpFileTime); if (!lpFileTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -191,6 +196,7 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF } BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FileTimeToDosDateTime(%p, %p, %p)\n", lpFileTime, lpFatDate, lpFatTime); if (!lpFileTime || !lpFatDate || !lpFatTime) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -220,6 +226,7 @@ BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate } DWORD WIN_FUNC GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetTimeZoneInformation(%p)\n", lpTimeZoneInformation); if (!lpTimeZoneInformation) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/winbase.cpp b/dll/kernel32/winbase.cpp index d969d23..bde8f51 100644 --- a/dll/kernel32/winbase.cpp +++ b/dll/kernel32/winbase.cpp @@ -303,6 +303,7 @@ const uint16_t kComputerNameWide[] = {u'C', u'O', u'M', u'P', u'N', u'A', u'M', namespace kernel32 { ATOM WIN_FUNC AddAtomA(LPCSTR lpString) { + WIN_API_SEGMENT_GUARD(); ATOM atom = 0; if (tryHandleIntegerAtomPointer(lpString, atom)) { DEBUG_LOG("AddAtomA(int:%u)\n", atom); @@ -325,6 +326,7 @@ ATOM WIN_FUNC AddAtomA(LPCSTR lpString) { } ATOM WIN_FUNC AddAtomW(LPCWSTR lpString) { + WIN_API_SEGMENT_GUARD(); ATOM atom = 0; if (tryHandleIntegerAtomPointer(lpString, atom)) { DEBUG_LOG("AddAtomW(int:%u)\n", atom); @@ -349,6 +351,7 @@ ATOM WIN_FUNC AddAtomW(LPCWSTR lpString) { } ATOM WIN_FUNC FindAtomA(LPCSTR lpString) { + WIN_API_SEGMENT_GUARD(); ATOM atom = 0; if (tryHandleIntegerAtomPointer(lpString, atom)) { DEBUG_LOG("FindAtomA(int:%u)\n", atom); @@ -371,6 +374,7 @@ ATOM WIN_FUNC FindAtomA(LPCSTR lpString) { } ATOM WIN_FUNC FindAtomW(LPCWSTR lpString) { + WIN_API_SEGMENT_GUARD(); ATOM atom = 0; if (tryHandleIntegerAtomPointer(lpString, atom)) { DEBUG_LOG("FindAtomW(int:%u)\n", atom); @@ -395,6 +399,7 @@ ATOM WIN_FUNC FindAtomW(LPCWSTR lpString) { } UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetAtomNameA(%u, %p, %d)\n", nAtom, lpBuffer, nSize); if (!lpBuffer || nSize <= 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -427,6 +432,7 @@ UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) { } UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetAtomNameW(%u, %p, %d)\n", nAtom, lpBuffer, nSize); if (!lpBuffer || nSize <= 0) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -463,6 +469,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) { } UINT WIN_FUNC SetHandleCount(UINT uNumber) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetHandleCount(%u)\n", uNumber); (void)uNumber; return 0x3FFE; @@ -470,6 +477,7 @@ UINT WIN_FUNC SetHandleCount(UINT uNumber) { DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list *Arguments) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("FormatMessageA(%u, %p, %u, %u, %p, %u, %p)\n", dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments); @@ -514,16 +522,19 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId } PVOID WIN_FUNC EncodePointer(PVOID Ptr) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("EncodePointer(%p)\n", Ptr); return Ptr; } PVOID WIN_FUNC DecodePointer(PVOID Ptr) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("DecodePointer(%p)\n", Ptr); return Ptr; } BOOL WIN_FUNC SetDllDirectoryA(LPCSTR lpPathName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetDllDirectoryA(%s)\n", lpPathName); if (!lpPathName || lpPathName[0] == '\0') { wibo::clearDllDirectoryOverride(); @@ -565,6 +576,7 @@ void tryMarkExecutable(void *mem) { } BOOL WIN_FUNC IsBadReadPtr(LPCVOID lp, UINT_PTR ucb) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: IsBadReadPtr(ptr=%p, size=%zu)\n", lp, static_cast(ucb)); if (!lp) { return TRUE; @@ -573,6 +585,7 @@ BOOL WIN_FUNC IsBadReadPtr(LPCVOID lp, UINT_PTR ucb) { } BOOL WIN_FUNC IsBadWritePtr(LPVOID lp, UINT_PTR ucb) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: IsBadWritePtr(ptr=%p, size=%zu)\n", lp, static_cast(ucb)); if (!lp && ucb != 0) { return TRUE; @@ -581,6 +594,7 @@ BOOL WIN_FUNC IsBadWritePtr(LPVOID lp, UINT_PTR ucb) { } BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetComputerNameA(%p, %p)\n", lpBuffer, nSize); if (!nSize || !lpBuffer) { if (nSize) { @@ -603,6 +617,7 @@ BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) { } BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetComputerNameW(%p, %p)\n", lpBuffer, nSize); if (!nSize || !lpBuffer) { if (nSize) { @@ -625,6 +640,7 @@ BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) { } HGLOBAL WIN_FUNC GlobalAlloc(UINT uFlags, SIZE_T dwBytes) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("GlobalAlloc(%x, %zu)\n", uFlags, static_cast(dwBytes)); if (uFlags & GMEM_MOVEABLE) { // not implemented rn @@ -636,12 +652,14 @@ HGLOBAL WIN_FUNC GlobalAlloc(UINT uFlags, SIZE_T dwBytes) { } HGLOBAL WIN_FUNC GlobalFree(HGLOBAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("GlobalFree(%p)\n", hMem); std::free(hMem); return nullptr; } HGLOBAL WIN_FUNC GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("GlobalReAlloc(%p, %zu, %x)\n", hMem, static_cast(dwBytes), uFlags); if (uFlags & GMEM_MODIFY) { assert(0); @@ -652,12 +670,14 @@ HGLOBAL WIN_FUNC GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags) { } UINT WIN_FUNC GlobalFlags(HGLOBAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("GlobalFlags(%p)\n", hMem); (void)hMem; return 0; } HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalAlloc(%x, %zu)\n", uFlags, static_cast(uBytes)); bool zero = (uFlags & LMEM_ZEROINIT) != 0; if ((uFlags & LMEM_MOVEABLE) != 0) { @@ -676,6 +696,7 @@ HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) { } HLOCAL WIN_FUNC LocalFree(HLOCAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalFree(%p)\n", hMem); // Windows returns NULL on success. std::free(hMem); @@ -684,6 +705,7 @@ HLOCAL WIN_FUNC LocalFree(HLOCAL hMem) { } HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalReAlloc(%p, %zu, %x)\n", hMem, static_cast(uBytes), uFlags); bool zero = (uFlags & LMEM_ZEROINIT) != 0; if ((uFlags & LMEM_MOVEABLE) != 0) { @@ -702,17 +724,20 @@ HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) { } HLOCAL WIN_FUNC LocalHandle(LPCVOID pMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalHandle(%p)\n", pMem); return const_cast(pMem); } LPVOID WIN_FUNC LocalLock(HLOCAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalLock(%p)\n", hMem); wibo::lastError = ERROR_SUCCESS; return hMem; } BOOL WIN_FUNC LocalUnlock(HLOCAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalUnlock(%p)\n", hMem); (void)hMem; wibo::lastError = ERROR_SUCCESS; @@ -720,11 +745,13 @@ BOOL WIN_FUNC LocalUnlock(HLOCAL hMem) { } SIZE_T WIN_FUNC LocalSize(HLOCAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalSize(%p)\n", hMem); return hMem ? mi_usable_size(hMem) : 0; } UINT WIN_FUNC LocalFlags(HLOCAL hMem) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("LocalFlags(%p)\n", hMem); (void)hMem; return 0; @@ -733,6 +760,7 @@ UINT WIN_FUNC LocalFlags(HLOCAL hMem) { static constexpr const char *kSystemDirectoryA = "C:\\Windows\\System32"; UINT WIN_FUNC GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemDirectoryA(%p, %u)\n", lpBuffer, uSize); if (!lpBuffer) { return 0; @@ -747,6 +775,7 @@ UINT WIN_FUNC GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize) { } UINT WIN_FUNC GetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemDirectoryW(%p, %u)\n", lpBuffer, uSize); if (!lpBuffer) { return 0; @@ -762,6 +791,7 @@ UINT WIN_FUNC GetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize) { } UINT WIN_FUNC GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemWow64DirectoryA(%p, %u)\n", lpBuffer, uSize); (void)lpBuffer; (void)uSize; @@ -770,6 +800,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize) { } UINT WIN_FUNC GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetSystemWow64DirectoryW(%p, %u)\n", lpBuffer, uSize); (void)lpBuffer; (void)uSize; @@ -778,6 +809,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize) { } UINT WIN_FUNC GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetWindowsDirectoryA(%p, %u)\n", lpBuffer, uSize); if (!lpBuffer) { return 0; @@ -793,6 +825,7 @@ UINT WIN_FUNC GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize) { } DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCurrentDirectoryA(%u, %p)\n", nBufferLength, lpBuffer); std::string path; @@ -818,6 +851,7 @@ DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) { } DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCurrentDirectoryW(%u, %p)\n", nBufferLength, lpBuffer); std::string path; @@ -843,6 +877,7 @@ DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) { } int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetCurrentDirectoryA(%s)\n", lpPathName ? lpPathName : "(null)"); if (!lpPathName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -861,6 +896,7 @@ int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) { } int WIN_FUNC SetCurrentDirectoryW(LPCWSTR lpPathName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("SetCurrentDirectoryW\n"); if (!lpPathName) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -871,6 +907,7 @@ int WIN_FUNC SetCurrentDirectoryW(LPCWSTR lpPathName) { } DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLongPathNameA(%s, %p, %u)\n", lpszShortPath ? lpszShortPath : "(null)", lpszLongPath, cchBuffer); if (!lpszShortPath) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -901,6 +938,7 @@ DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD } DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLongPathNameW(%p, %p, %u)\n", lpszShortPath, lpszLongPath, cchBuffer); if (!lpszShortPath) { wibo::lastError = ERROR_INVALID_PARAMETER; @@ -931,6 +969,7 @@ DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWOR BOOL WIN_FUNC GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetDiskFreeSpaceA(%s)\n", lpRootPathName ? lpRootPathName : "(null)"); struct statvfs buf{}; std::string resolvedPath; @@ -983,6 +1022,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerClust BOOL WIN_FUNC GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters) { + WIN_API_SEGMENT_GUARD(); std::string rootPath = wideStringToString(lpRootPathName); return GetDiskFreeSpaceA(lpRootPathName ? rootPath.c_str() : nullptr, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters); @@ -990,6 +1030,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerClus BOOL WIN_FUNC GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, uint64_t *lpFreeBytesAvailableToCaller, uint64_t *lpTotalNumberOfBytes, uint64_t *lpTotalNumberOfFreeBytes) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetDiskFreeSpaceExA(%s)\n", lpDirectoryName ? lpDirectoryName : "(null)"); struct statvfs buf{}; std::string resolvedPath; @@ -1026,6 +1067,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, uint64_t *lpFreeBytesA BOOL WIN_FUNC GetDiskFreeSpaceExW(LPCWSTR lpDirectoryName, uint64_t *lpFreeBytesAvailableToCaller, uint64_t *lpTotalNumberOfBytes, uint64_t *lpTotalNumberOfFreeBytes) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetDiskFreeSpaceExW -> "); std::string directoryName = wideStringToString(lpDirectoryName); return GetDiskFreeSpaceExA(lpDirectoryName ? directoryName.c_str() : nullptr, lpFreeBytesAvailableToCaller, diff --git a/dll/kernel32/wincon.cpp b/dll/kernel32/wincon.cpp index 841d23c..5ee646a 100644 --- a/dll/kernel32/wincon.cpp +++ b/dll/kernel32/wincon.cpp @@ -9,6 +9,7 @@ namespace kernel32 { BOOL WIN_FUNC GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetConsoleMode(%p)\n", hConsoleHandle); if (lpMode) { *lpMode = 0; @@ -18,6 +19,7 @@ BOOL WIN_FUNC GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode) { } BOOL WIN_FUNC SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetConsoleMode(%p, 0x%x)\n", hConsoleHandle, dwMode); (void)hConsoleHandle; (void)dwMode; @@ -26,18 +28,21 @@ BOOL WIN_FUNC SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode) { } UINT WIN_FUNC GetConsoleCP() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetConsoleCP() -> 65001\n"); wibo::lastError = ERROR_SUCCESS; return 65001; // UTF-8 } UINT WIN_FUNC GetConsoleOutputCP() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetConsoleOutputCP() -> 65001\n"); wibo::lastError = ERROR_SUCCESS; return 65001; // UTF-8 } BOOL WIN_FUNC SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: SetConsoleCtrlHandler(%p, %u)\n", reinterpret_cast(HandlerRoutine), Add); (void)HandlerRoutine; (void)Add; @@ -46,6 +51,7 @@ BOOL WIN_FUNC SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add) { } BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_BUFFER_INFO *lpConsoleScreenBufferInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetConsoleScreenBufferInfo(%p, %p)\n", hConsoleOutput, lpConsoleScreenBufferInfo); (void)hConsoleOutput; if (!lpConsoleScreenBufferInfo) { @@ -63,6 +69,7 @@ BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_B BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("WriteConsoleW(%p, %p, %u, %p, %p)\n", hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved); (void)lpReserved; @@ -90,6 +97,7 @@ BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumb } DWORD WIN_FUNC GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetConsoleTitleA(%p, %u)\n", lpConsoleTitle, nSize); if (lpConsoleTitle && nSize > 0) { lpConsoleTitle[0] = '\0'; @@ -99,6 +107,7 @@ DWORD WIN_FUNC GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize) { } DWORD WIN_FUNC GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetConsoleTitleW(%p, %u)\n", lpConsoleTitle, nSize); if (lpConsoleTitle && nSize > 0) { lpConsoleTitle[0] = 0; @@ -109,6 +118,7 @@ DWORD WIN_FUNC GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) { BOOL WIN_FUNC PeekConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: PeekConsoleInputA(%p, %p, %u)\n", hConsoleInput, lpBuffer, nLength); (void)hConsoleInput; (void)lpBuffer; @@ -122,6 +132,7 @@ BOOL WIN_FUNC PeekConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DW BOOL WIN_FUNC ReadConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: ReadConsoleInputA(%p, %p, %u)\n", hConsoleInput, lpBuffer, nLength); (void)hConsoleInput; (void)lpBuffer; diff --git a/dll/kernel32/winnls.cpp b/dll/kernel32/winnls.cpp index 0a359e1..b00836f 100644 --- a/dll/kernel32/winnls.cpp +++ b/dll/kernel32/winnls.cpp @@ -82,22 +82,26 @@ std::string localeInfoString(int LCType) { namespace kernel32 { UINT WIN_FUNC GetACP() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetACP() -> %u\n", 28591); wibo::lastError = ERROR_SUCCESS; return 28591; // Latin1 (ISO/IEC 8859-1) } LANGID WIN_FUNC GetSystemDefaultLangID() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetSystemDefaultLangID()\n"); return 0; } LANGID WIN_FUNC GetUserDefaultUILanguage() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: GetUserDefaultUILanguage()\n"); return 0; } BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetCPInfo(%u, %p)\n", CodePage, lpCPInfo); (void)CodePage; @@ -117,6 +121,7 @@ BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) { int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2, int cchCount2) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CompareStringA(%u, %u, %s, %d, %s, %d)\n", Locale, dwCmpFlags, lpString1 ? lpString1 : "(null)", cchCount1, lpString2 ? lpString2 : "(null)", cchCount2); (void)Locale; @@ -140,6 +145,7 @@ int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int cchCount1, LPCWCH lpString2, int cchCount2) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CompareStringW(%u, %u, %p, %d, %p, %d)\n", Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2); (void)Locale; @@ -155,6 +161,7 @@ int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int } BOOL WIN_FUNC IsValidCodePage(UINT CodePage) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsValidCodePage(%u)\n", CodePage); (void)CodePage; wibo::lastError = ERROR_SUCCESS; @@ -162,6 +169,7 @@ BOOL WIN_FUNC IsValidCodePage(UINT CodePage) { } BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsValidLocale(%u, 0x%x)\n", Locale, dwFlags); (void)Locale; if (dwFlags != 0 && (dwFlags & ~(LCID_INSTALLED | LCID_SUPPORTED | LCID_ALTERNATE_SORTS)) != 0) { @@ -173,6 +181,7 @@ BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) { } int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLocaleInfoA(%u, %u, %p, %d)\n", Locale, LCType, lpLCData, cchData); (void)Locale; @@ -198,6 +207,7 @@ int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchD } int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetLocaleInfoW(%u, %u, %p, %d)\n", Locale, LCType, lpLCData, cchData); (void)Locale; @@ -224,6 +234,7 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch } BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("EnumSystemLocalesA(%p, 0x%x)\n", lpLocaleEnumProc, dwFlags); (void)dwFlags; if (!lpLocaleEnumProc) { @@ -237,12 +248,14 @@ BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlag } LCID WIN_FUNC GetUserDefaultLCID() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetUserDefaultLCID()\n"); wibo::lastError = ERROR_SUCCESS; return 0x0409; // en-US } BOOL WIN_FUNC IsDBCSLeadByte(BYTE TestChar) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsDBCSLeadByte(%u)\n", TestChar); (void)TestChar; wibo::lastError = ERROR_SUCCESS; @@ -250,6 +263,7 @@ BOOL WIN_FUNC IsDBCSLeadByte(BYTE TestChar) { } BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsDBCSLeadByteEx(%u, %u)\n", CodePage, TestChar); auto inRanges = [TestChar](std::initializer_list> ranges) -> BOOL { @@ -282,6 +296,7 @@ BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) { } int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LCMapStringW(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest); (void)Locale; if (!lpSrcStr || cchSrc == 0) { @@ -330,6 +345,7 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc } int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LCMapStringA(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest); if (!lpSrcStr) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/kernel32/winnt.cpp b/dll/kernel32/winnt.cpp index 2f3eba4..2b061b7 100644 --- a/dll/kernel32/winnt.cpp +++ b/dll/kernel32/winnt.cpp @@ -5,6 +5,7 @@ namespace kernel32 { void WIN_FUNC RtlUnwind(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RtlUnwind(%p, %p, %p, %p)\n", TargetFrame, TargetIp, ExceptionRecord, ReturnValue); DEBUG_LOG("WARNING: Silently returning from RtlUnwind - exception handlers and clean up code may not be run\n"); } diff --git a/dll/kernel32/wow64apiset.cpp b/dll/kernel32/wow64apiset.cpp index ffaa3f1..c828c28 100644 --- a/dll/kernel32/wow64apiset.cpp +++ b/dll/kernel32/wow64apiset.cpp @@ -7,6 +7,7 @@ namespace kernel32 { BOOL WIN_FUNC Wow64DisableWow64FsRedirection(PVOID *OldValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: Wow64DisableWow64FsRedirection(%p)\n", OldValue); if (OldValue) { *OldValue = nullptr; @@ -16,6 +17,7 @@ BOOL WIN_FUNC Wow64DisableWow64FsRedirection(PVOID *OldValue) { } BOOL WIN_FUNC Wow64RevertWow64FsRedirection(PVOID OldValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: Wow64RevertWow64FsRedirection(%p)\n", OldValue); (void)OldValue; wibo::lastError = ERROR_SUCCESS; @@ -23,6 +25,7 @@ BOOL WIN_FUNC Wow64RevertWow64FsRedirection(PVOID OldValue) { } BOOL WIN_FUNC IsWow64Process(HANDLE hProcess, PBOOL Wow64Process) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("IsWow64Process(%p, %p)\n", hProcess, Wow64Process); if (!Wow64Process) { wibo::lastError = ERROR_INVALID_PARAMETER; diff --git a/dll/lmgr.cpp b/dll/lmgr.cpp index e79d5f7..aaec2ad 100644 --- a/dll/lmgr.cpp +++ b/dll/lmgr.cpp @@ -2,12 +2,14 @@ namespace lmgr { int WIN_ENTRY lp_checkout(int a, int b, const char* c, const char* d, int e, const char* f, int* out) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("lp_checkout(%d, %d, %s, %s, %d, %s)\n", a, b, c, d, e, f); *out = 1234; return 0; } int WIN_ENTRY lp_checkin() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("lp_checkin()\n"); return 0; } diff --git a/dll/mscoree.cpp b/dll/mscoree.cpp index 0072b63..e6e8554 100644 --- a/dll/mscoree.cpp +++ b/dll/mscoree.cpp @@ -3,6 +3,7 @@ namespace mscoree { void WIN_FUNC CorExitProcess(int exitCode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("CorExitProcess(%i)\n", exitCode); exit(exitCode); } diff --git a/dll/msvcrt.cpp b/dll/msvcrt.cpp index f99d4d4..497ce3e 100644 --- a/dll/msvcrt.cpp +++ b/dll/msvcrt.cpp @@ -230,10 +230,12 @@ namespace msvcrt { } IOBProxy *WIN_ENTRY __iob_func() { + WIN_API_SEGMENT_GUARD(); return standardIobEntries(); } IOBProxy *WIN_ENTRY __p__iob() { + WIN_API_SEGMENT_GUARD(); return standardIobEntries(); } @@ -268,6 +270,7 @@ namespace msvcrt { } void WIN_ENTRY setbuf(FILE *stream, char *buffer) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("setbuf(%p, %p)\n", stream, buffer); if (!stream) { return; @@ -281,6 +284,7 @@ namespace msvcrt { } void WIN_ENTRY _splitpath(const char *path, char *drive, char *dir, char *fname, char *ext) { + WIN_API_SEGMENT_GUARD(); if (drive) drive[0] = '\0'; if (dir) dir[0] = '\0'; if (fname) fname[0] = '\0'; @@ -345,6 +349,7 @@ namespace msvcrt { } int WIN_ENTRY _fileno(FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_fileno(%p)\n", stream); if (!stream) { errno = EINVAL; @@ -381,18 +386,21 @@ namespace msvcrt { } int WIN_ENTRY _getmbcp() { + WIN_API_SEGMENT_GUARD(); ensureMbctypeInitialized(); DEBUG_LOG("_getmbcp() -> %d\n", mbCodePageSetting); return mbCodePageSetting; } unsigned int* WIN_ENTRY __p___mb_cur_max() { + WIN_API_SEGMENT_GUARD(); ensureMbctypeInitialized(); DEBUG_LOG("__p___mb_cur_max() -> %u\n", mbCurMaxValue); return &mbCurMaxValue; } int WIN_ENTRY _setmbcp(int codepage) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_setmbcp(%d)\n", codepage); ensureMbctypeInitialized(); @@ -418,12 +426,14 @@ namespace msvcrt { } unsigned char *WIN_ENTRY __p__mbctype() { + WIN_API_SEGMENT_GUARD(); ensureMbctypeInitialized(); DEBUG_LOG("__p__mbctype() -> %p\n", mbctypeTable().data()); return mbctypeTable().data(); } unsigned short **WIN_ENTRY __p__pctype() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__pctype()\n"); static unsigned short *pointer = nullptr; pointer = pctypeTable().data() + 1; @@ -431,6 +441,7 @@ namespace msvcrt { } int WIN_ENTRY _isctype(int ch, int mask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_isctype(%d, %d)\n", ch, mask); if (ch == EOF) { return 0; @@ -667,21 +678,25 @@ namespace msvcrt { // Stub because we're only ever a console application void WIN_ENTRY __set_app_type(int at) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: __set_app_type(%d)\n", at); (void)at; } int* WIN_FUNC __p__fmode() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__fmode() -> %p\n", &_fmode); return &_fmode; } int* WIN_FUNC __p__commode() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__commode() -> %p\n", &_commode); return &_commode; } void WIN_ENTRY _initterm(const _PVFV *ppfn, const _PVFV* end) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_initterm(%p, %p)\n", ppfn, end); for (; ppfn < end; ppfn++) { _PVFV func = *ppfn; @@ -693,6 +708,7 @@ namespace msvcrt { } int WIN_ENTRY _initterm_e(const _PIFV *ppfn, const _PIFV *end) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_initterm_e(%p, %p)\n", ppfn, end); for (; ppfn < end; ppfn++) { _PIFV func = *ppfn; @@ -707,6 +723,7 @@ namespace msvcrt { } unsigned int WIN_ENTRY _controlfp(unsigned int newControl, unsigned int mask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_controlfp(newControl=%08x, mask=%08x)\n", newControl, mask); unsigned int previous = floatingPointControlWord; if (mask != 0) { @@ -716,6 +733,7 @@ namespace msvcrt { } int WIN_ENTRY _controlfp_s(unsigned int *currentControl, unsigned int newControl, unsigned int mask) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_controlfp_s(currentControl=%p, newControl=%08x, mask=%08x)\n", currentControl, newControl, mask); if (mask != 0 && (mask & 0xFF000000) != 0) { // Unsupported bits: match real CRT behaviour by ignoring but logging. @@ -731,6 +749,7 @@ namespace msvcrt { } _PIFV WIN_ENTRY _onexit(_PIFV func) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_onexit(%p)\n", func); if(!func) return nullptr; if (atexit(reinterpret_cast(func)) != 0) return nullptr; @@ -739,6 +758,7 @@ namespace msvcrt { // NOLINTNEXTLINE(readability-non-const-parameter) int WIN_ENTRY __wgetmainargs(int *wargc, uint16_t ***wargv, uint16_t ***wenv, int doWildcard, int *startInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__wgetmainargs(doWildcard=%d)\n", doWildcard); (void)startInfo; if (doWildcard) { @@ -751,6 +771,7 @@ namespace msvcrt { // NOLINTNEXTLINE(readability-non-const-parameter) int WIN_ENTRY __getmainargs(int *argc, char ***argv, char ***env, int doWildcard, int *startInfo) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__getmainargs(doWildcard=%d)\n", doWildcard); (void)startInfo; if (doWildcard) { @@ -760,26 +781,31 @@ namespace msvcrt { } char* WIN_ENTRY getenv(const char *varname){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("getenv(%s)\n", varname); return std::getenv(varname); } char*** WIN_ENTRY __p___initenv() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p___initenv() -> %p\n", &__initenv); return &__initenv; } char* WIN_ENTRY strcat(char *dest, const char *src) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcat(%p, %s)\n", dest, src); return std::strcat(dest, src); } char* WIN_ENTRY strcpy(char *dest, const char *src) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcpy(%p, %s)\n", dest, src); return std::strcpy(dest, src); } int WIN_ENTRY _access(const char *path, int mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_access(%s, %d)\n", path ? path : "(null)", mode); if (!path) { errno = EINVAL; @@ -806,6 +832,7 @@ namespace msvcrt { } int WIN_ENTRY _ismbblead(unsigned int c) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ismbblead(%d)\n", c); if (c > 0xFF) { return 0; @@ -814,6 +841,7 @@ namespace msvcrt { } int WIN_ENTRY _ismbbtrail(unsigned int c) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ismbbtrail(%d)\n", c); if (c > 0xFF) { return 0; @@ -822,6 +850,7 @@ namespace msvcrt { } int WIN_ENTRY _ismbcspace(unsigned int c) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ismbcspace(%d)\n", c); if (c <= 0xFF) { return std::isspace(static_cast(c)) ? 1 : 0; @@ -839,6 +868,7 @@ namespace msvcrt { } void WIN_ENTRY _mbccpy(unsigned char *dest, const unsigned char *src) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbccpy(%p, %s)\n", dest, src); if (!dest || !src) { return; @@ -851,6 +881,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbsinc(const unsigned char *str) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsinc(%p)\n", str); if (!str) { return nullptr; @@ -865,6 +896,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbsdec(const unsigned char *start, const unsigned char *current) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsdec(%p, %p)\n", start, current); if (!start || !current || current <= start) { DEBUG_LOG("_mbsdec invalid args start=%p current=%p\n", start, current); @@ -901,6 +933,7 @@ namespace msvcrt { } unsigned int WIN_ENTRY _mbclen(const unsigned char *str) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbclen(%s)\n", str); if (!str || *str == '\0') { return 0; @@ -909,6 +942,7 @@ namespace msvcrt { } int WIN_ENTRY _mbscmp(const unsigned char *lhs, const unsigned char *rhs) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbscmp(%s, %s)\n", lhs, rhs); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -917,6 +951,7 @@ namespace msvcrt { } int WIN_ENTRY _mbsicmp(const unsigned char *lhs, const unsigned char *rhs) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsicmp(%s, %s)\n", lhs, rhs); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -925,6 +960,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbsstr(const unsigned char *haystack, const unsigned char *needle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsstr(%s, %s)\n", haystack, needle); if (!haystack || !needle) { return nullptr; @@ -934,6 +970,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbschr(const unsigned char *str, unsigned int ch) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbschr(%s, %d)\n", str, ch); if (!str) { return nullptr; @@ -944,6 +981,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbsrchr(const unsigned char *str, unsigned int ch) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsrchr(%s, %d)\n", str, ch); if (!str) { return nullptr; @@ -954,6 +992,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbslwr(unsigned char *str) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbslwr(%p)\n", str); if (!str) { return nullptr; @@ -965,6 +1004,7 @@ namespace msvcrt { } unsigned char* WIN_ENTRY _mbsupr(unsigned char *str) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsupr(%p)\n", str); if (!str) { return nullptr; @@ -976,16 +1016,19 @@ namespace msvcrt { } unsigned char *WIN_ENTRY _mbsinc_l(const unsigned char *str, void *) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsinc_l(%p)\n", str); return _mbsinc(str); } unsigned char *WIN_ENTRY _mbsdec_l(const unsigned char *start, const unsigned char *current, void *locale) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsdec_l(%p, %p, %p)\n", start, current, locale); return _mbsdec(start, current); } int WIN_ENTRY _mbsncmp(const unsigned char *lhs, const unsigned char *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsncmp(%s, %s, %zu)\n", lhs, rhs, count); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -994,6 +1037,7 @@ namespace msvcrt { } size_t WIN_ENTRY _mbsspn(const unsigned char *str, const unsigned char *set) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mbsspn(%s, %s)\n", str, set); if (!str || !set) { return 0; @@ -1002,6 +1046,7 @@ namespace msvcrt { } int WIN_ENTRY _ismbcdigit(unsigned int ch) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ismbcdigit(%d)\n", ch); if (ch <= 0xFF) { return std::isdigit(static_cast(ch)) ? 1 : 0; @@ -1010,6 +1055,7 @@ namespace msvcrt { } int WIN_ENTRY _stricmp(const char *lhs, const char *rhs) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_stricmp(%s, %s)\n", lhs, rhs); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -1018,6 +1064,7 @@ namespace msvcrt { } int WIN_ENTRY _strnicmp(const char *lhs, const char *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_strnicmp(%s, %s, %zu)\n", lhs, rhs, count); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -1026,6 +1073,7 @@ namespace msvcrt { } int WIN_ENTRY _memicmp(const void *lhs, const void *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_memicmp(%p, %p, %zu)\n", lhs, rhs, count); if (!lhs || !rhs) { return (lhs == rhs) ? 0 : (lhs ? 1 : -1); @@ -1043,6 +1091,7 @@ namespace msvcrt { } int WIN_ENTRY _vsnprintf(char *buffer, size_t count, const char *format, va_list args) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_vsnprintf(%p, %zu, %s, %p)\n", buffer, count, format, args); if (!buffer || !format) { errno = EINVAL; @@ -1060,6 +1109,7 @@ namespace msvcrt { } int WIN_ENTRY _snprintf(char *buffer, size_t count, const char *format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_snprintf(%p, %zu, %s, ...)\n", buffer, count, format); va_list args; va_start(args, format); @@ -1069,6 +1119,7 @@ namespace msvcrt { } int WIN_ENTRY sprintf(char *buffer, const char *format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("sprintf(%p, %s, ...)\n", buffer, format); va_list args; va_start(args, format); @@ -1078,6 +1129,7 @@ namespace msvcrt { } int WIN_ENTRY printf(const char *format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("printf(%s, ...)\n", format); va_list args; va_start(args, format); @@ -1087,6 +1139,7 @@ namespace msvcrt { } int WIN_ENTRY sscanf(const char *buffer, const char *format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("sscanf(%p, %p, ...)\n", buffer, format); va_list args; va_start(args, format); @@ -1096,6 +1149,7 @@ namespace msvcrt { } char *WIN_ENTRY fgets(char *str, int count, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fgets(%p, %d, %p)\n", str, count, stream); if (!str || count <= 0) { return nullptr; @@ -1105,12 +1159,14 @@ namespace msvcrt { } size_t WIN_ENTRY fread(void *buffer, size_t size, size_t count, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fread(%p, %zu, %zu, %p)\n", buffer, size, count, stream); FILE *host = mapToHostFile(stream); return ::fread(buffer, size, count, host); } FILE *WIN_ENTRY _fsopen(const char *filename, const char *mode, int shflag) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_fsopen(%s, %s, %d)\n", filename ? filename : "(null)", mode ? mode : "(null)", shflag); (void)shflag; if (!filename || !mode) { @@ -1122,6 +1178,7 @@ namespace msvcrt { } int WIN_ENTRY _sopen(const char *path, int oflag, int shflag, int pmode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_sopen(%s, %d, %d, %d)\n", path ? path : "(null)", oflag, shflag, pmode); (void)shflag; if (!path) { @@ -1135,22 +1192,26 @@ namespace msvcrt { } int WIN_ENTRY _read(int fd, void *buffer, unsigned int count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_read(%d, %p, %u)\n", fd, buffer, count); return static_cast(::read(fd, buffer, count)); } int WIN_ENTRY _close(int fd) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_close(%d)\n", fd); return ::close(fd); } long WIN_ENTRY _lseek(int fd, long offset, int origin) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_lseek(%d, %ld, %d)\n", fd, offset, origin); off_t result = ::lseek(fd, static_cast(offset), origin); return static_cast(result); } int WIN_ENTRY _unlink(const char *path) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_unlink(%s)\n", path ? path : "(null)"); if (!path) { errno = EINVAL; @@ -1161,6 +1222,7 @@ namespace msvcrt { } int WIN_ENTRY _utime(const char *path, const _utimbuf *times) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_utime(%s, %p)\n", path ? path : "(null)", times); if (!path) { errno = EINVAL; @@ -1175,49 +1237,58 @@ namespace msvcrt { } int WIN_ENTRY _chsize(int fd, long size) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_chsize(%d, %ld)\n", fd, size); return ::ftruncate(fd, static_cast(size)); } char* WIN_ENTRY strncpy(char *dest, const char *src, size_t count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strncpy(%p, %s, %zu)\n", dest, src ? src : "(null)", count); return std::strncpy(dest, src, count); } char* WIN_ENTRY strpbrk(const char *str, const char *accept) { + WIN_API_SEGMENT_GUARD(); const char *result = std::strpbrk(str, accept); DEBUG_LOG("strpbrk(%s, %s) -> %p\n", str ? str : "(null)", accept ? accept : "(null)", result); return result ? const_cast(result) : nullptr; } char* WIN_ENTRY strstr(const char *haystack, const char *needle) { + WIN_API_SEGMENT_GUARD(); const char *result = std::strstr(haystack, needle); DEBUG_LOG("strstr(%s, %s) -> %p\n", haystack ? haystack : "(null)", needle ? needle : "(null)", result); return result ? const_cast(result) : nullptr; } char* WIN_ENTRY strrchr(const char *str, int ch) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strrchr(%s, %c)\n", str ? str : "(null)", ch); const char *result = std::strrchr(str, ch); return result ? const_cast(result) : nullptr; } char* WIN_ENTRY strtok(char *str, const char *delim) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strtok(%p, %s)\n", str, delim ? delim : "(null)"); return std::strtok(str, delim); } long WIN_ENTRY _adj_fdiv_r(long value) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _adj_fdiv_r(%ld)\n", value); return value; } void WIN_ENTRY _adjust_fdiv(long n) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _adjust_fdiv(%ld)\n", n); (void)n; } int WIN_ENTRY _ftime(struct _timeb *timeptr) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ftime(%p)\n", timeptr); if (!timeptr) { errno = EINVAL; @@ -1235,6 +1306,7 @@ namespace msvcrt { } unsigned long WIN_ENTRY _ultoa(unsigned long value, char *str, int radix) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ultoa(%lu, %p, %d)\n", value, str, radix); if (!str || radix < 2 || radix > 36) { errno = EINVAL; @@ -1256,6 +1328,7 @@ namespace msvcrt { } char* WIN_ENTRY _ltoa(long value, char *str, int radix) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_ltoa(%ld, %p, %d)\n", value, str, radix); if (!str || radix < 2 || radix > 36) { errno = EINVAL; @@ -1275,6 +1348,7 @@ namespace msvcrt { } char* WIN_ENTRY _makepath(char *path, const char *drive, const char *dir, const char *fname, const char *ext) { + WIN_API_SEGMENT_GUARD(); if (!path) { return nullptr; } @@ -1308,6 +1382,7 @@ namespace msvcrt { } char* WIN_ENTRY _fullpath(char *absPath, const char *relPath, size_t maxLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_fullpath(%p, %s, %zu)\n", absPath, relPath ? relPath : "(null)", maxLength); if (!relPath) { errno = EINVAL; @@ -1338,6 +1413,7 @@ namespace msvcrt { } int WIN_ENTRY _putenv(const char *envString) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_putenv(%s)\n", envString ? envString : "(null)"); if (!envString) { errno = EINVAL; @@ -1355,6 +1431,7 @@ namespace msvcrt { } char *WIN_ENTRY _mktemp(char *templateName) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_mktemp(%s)\n", templateName); if (!templateName) { errno = EINVAL; @@ -1383,16 +1460,19 @@ namespace msvcrt { } int WIN_ENTRY _except_handler3(void *record, void *frame, void *context, void *dispatch) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_except_handler3(%p, %p, %p, %p)\n", record, frame, context, dispatch); return _except_handler4_common(record, frame, context, dispatch); } int WIN_ENTRY getchar() { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("getchar()\n"); return std::getchar(); } time_t WIN_ENTRY time(time_t *t) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("time(%p)\n", t); time_t result = std::time(nullptr); if (t) { @@ -1403,6 +1483,7 @@ namespace msvcrt { char *WIN_ENTRY __unDName(char *outputString, const char *mangledName, int maxStringLength, void *(*allocFunc)(size_t), void (*freeFunc)(void *), unsigned short) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: __unDName(%p, %s, %d, %p, %p)\n", outputString, mangledName ? mangledName : "(null)", maxStringLength, allocFunc, freeFunc); (void)allocFunc; @@ -1415,6 +1496,7 @@ namespace msvcrt { } char* WIN_ENTRY setlocale(int category, const char *locale){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("setlocale(%d, %s)\n", category, locale ? locale : "(null)"); char *result = std::setlocale(category, locale); if (result) { @@ -1424,6 +1506,7 @@ namespace msvcrt { } int WIN_ENTRY _wdupenv_s(uint16_t **buffer, size_t *numberOfElements, const uint16_t *varname){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_wdupenv_s(%p, %p, %s)\n", buffer, numberOfElements, wideStringToString(varname).c_str()); if (buffer) { *buffer = nullptr; @@ -1466,6 +1549,7 @@ namespace msvcrt { } int WIN_ENTRY _wgetenv_s(size_t* pReturnValue, uint16_t* buffer, size_t numberOfElements, const uint16_t* varname){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_wgetenv_s(%p, %p, %zu, %s)\n", pReturnValue, buffer, numberOfElements, wideStringToString(varname).c_str()); if (pReturnValue) { @@ -1508,26 +1592,31 @@ namespace msvcrt { } size_t WIN_ENTRY strlen(const char *str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strlen(%s)\n", str); return ::strlen(str); } int WIN_ENTRY strcmp(const char *lhs, const char *rhs) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcmp(%s, %s)\n", lhs, rhs); return ::strcmp(lhs, rhs); } int WIN_ENTRY strncmp(const char *lhs, const char *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strncmp(%s, %s, %zu)\n", lhs, rhs, count); return ::strncmp(lhs, rhs, count); } void WIN_ENTRY _exit(int status) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_exit(%d)\n", status); _Exit(status); } int WIN_ENTRY strcpy_s(char *dest, size_t dest_size, const char *src) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strcpy_s(%p, %zu, %s)\n", dest, dest_size, src); if (!dest || !src || dest_size == 0) { return 22; @@ -1544,6 +1633,7 @@ namespace msvcrt { } int WIN_ENTRY strcat_s(char *dest, size_t numberOfElements, const char *src) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strcat_s(%p, %zu, %s)\n", dest, numberOfElements, src); if (!dest || !src || numberOfElements == 0) { return 22; @@ -1561,6 +1651,7 @@ namespace msvcrt { } int WIN_ENTRY strncpy_s(char *dest, size_t dest_size, const char *src, size_t count) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strncpy_s(%p, %zu, %s, %zu)\n", dest, dest_size, src, count); constexpr size_t TRUNCATE = static_cast(-1); constexpr int STRUNCATE = 80; @@ -1608,6 +1699,7 @@ namespace msvcrt { } char *WIN_ENTRY _strdup(const char *strSource) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_strdup(%s)\n", strSource); if (!strSource) { return nullptr; @@ -1624,31 +1716,37 @@ namespace msvcrt { } unsigned long WIN_ENTRY strtoul(const char *str, char **endptr, int base) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strtoul(%s, %p, %d)\n", str, endptr, base); return ::strtoul(str, endptr, base); } void* WIN_ENTRY malloc(size_t size){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("malloc(%zu)\n", size); return std::malloc(size); } void* WIN_ENTRY calloc(size_t count, size_t size){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("calloc(%zu, %zu)\n", count, size); return std::calloc(count, size); } void* WIN_ENTRY realloc(void *ptr, size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("realloc(%p, %zu)\n", ptr, size); return std::realloc(ptr, size); } void* WIN_ENTRY _malloc_crt(size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_malloc_crt(%zu)\n", size); return std::malloc(size); } void WIN_ENTRY _lock(int locknum) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_lock(%d)\n", locknum); if (locknum < 0 || static_cast(locknum) >= LOCK_TABLE_SIZE) { DEBUG_LOG("_lock: unsupported lock %d\n", locknum); @@ -1658,6 +1756,7 @@ namespace msvcrt { } void WIN_ENTRY _unlock(int locknum) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_unlock(%d)\n", locknum); if (locknum < 0 || static_cast(locknum) >= LOCK_TABLE_SIZE) { DEBUG_LOG("_unlock: unsupported lock %d\n", locknum); @@ -1667,6 +1766,7 @@ namespace msvcrt { } _onexit_t WIN_ENTRY __dllonexit(_onexit_t func, _PVFV **pbegin, _PVFV **pend) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__dllonexit(%p, %p, %p)\n", func, pbegin, pend); if (!pbegin || !pend) { return nullptr; @@ -1698,31 +1798,37 @@ namespace msvcrt { } void WIN_ENTRY free(void* ptr){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("free(%p)\n", ptr); std::free(ptr); } void* WIN_ENTRY memcpy(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memcpy(%p, %p, %zu)\n", dest, src, count); return std::memcpy(dest, src, count); } void* WIN_ENTRY memmove(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memmove(%p, %p, %zu)\n", dest, src, count); return std::memmove(dest, src, count); } int WIN_ENTRY memcmp(const void *lhs, const void *rhs, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("memcmp(%p, %p, %zu)\n", lhs, rhs, count); return std::memcmp(lhs, rhs, count); } void WIN_ENTRY qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *)) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("qsort(%p, %zu, %zu, %p)\n", base, num, size, compar); std::qsort(base, num, size, compar); } int WIN_ENTRY fflush(FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fflush(%p)\n", stream); if (!stream) { return std::fflush(nullptr); @@ -1732,6 +1838,7 @@ namespace msvcrt { } int WIN_ENTRY vfwprintf(FILE *stream, const uint16_t *format, va_list args) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("vfwprintf(%p, %s, ...)\n", stream, wideStringToString(format).c_str()); FILE *host = mapToHostFile(stream ? stream : stdout); std::wstring fmt; @@ -1745,36 +1852,43 @@ namespace msvcrt { } FILE *WIN_ENTRY fopen(const char *filename, const char *mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fopen(%s, %s)\n", filename ? filename : "(null)", mode ? mode : "(null)"); return std::fopen(filename, mode); } int WIN_ENTRY _dup2(int fd1, int fd2) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_dup2(%d, %d)\n", fd1, fd2); return dup2(fd1, fd2); } int WIN_ENTRY _isatty(int fd) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_isatty(%d)\n", fd); return isatty(fd); } int WIN_ENTRY fseek(FILE *stream, long offset, int origin) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("fseek(%p, %ld, %d)\n", stream, offset, origin); return std::fseek(stream, offset, origin); } long WIN_ENTRY ftell(FILE *stream) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("ftell(%p)\n", stream); return std::ftell(stream); } int WIN_ENTRY feof(FILE *stream) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("feof(%p)\n", stream); return std::feof(stream); } int WIN_ENTRY fputws(const uint16_t *str, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fputws(%s, %p)\n", wideStringToString(str).c_str(), stream); std::wstring temp; if (str) { @@ -1786,11 +1900,13 @@ namespace msvcrt { } int WIN_ENTRY _cputws(const uint16_t *string) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_cputws(%s)\n", wideStringToString(string).c_str()); return fputws(string, stdout); } uint16_t* WIN_ENTRY fgetws(uint16_t *buffer, int size, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fgetws(%p, %d, %p)\n", buffer, size, stream); if (!buffer || size <= 0) { return nullptr; @@ -1810,11 +1926,13 @@ namespace msvcrt { } wint_t WIN_ENTRY fgetwc(FILE *stream) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("fgetwc(%p)\n", stream); return std::fgetwc(stream); } int WIN_ENTRY _wfopen_s(FILE **stream, const uint16_t *filename, const uint16_t *mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_wfopen_s(%p, %s, %s)\n", stream, wideStringToString(filename).c_str(), wideStringToString(mode).c_str()); if (!stream || !filename || !mode) { @@ -1833,6 +1951,7 @@ namespace msvcrt { } int WIN_ENTRY _wcsicmp(const uint16_t *lhs, const uint16_t *rhs) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_wcsicmp(%s, %s)\n", wideStringToString(lhs).c_str(), wideStringToString(rhs).c_str()); if (lhs == rhs) { return 0; @@ -1859,6 +1978,7 @@ namespace msvcrt { int WIN_ENTRY _wmakepath_s(uint16_t *path, size_t sizeInWords, const uint16_t *drive, const uint16_t *dir, const uint16_t *fname, const uint16_t *ext) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_wmakepath_s(%p, %zu, %s, %s, %s, %s)\n", path, sizeInWords, wideStringToString(drive).c_str(), wideStringToString(dir).c_str(), wideStringToString(fname).c_str(), wideStringToString(ext).c_str()); if (!path || sizeInWords == 0) { @@ -1930,6 +2050,7 @@ namespace msvcrt { } int WIN_ENTRY _wputenv_s(const uint16_t *varname, const uint16_t *value) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_wputenv_s(%p, %p)\n", varname, value); if (!varname || !value) { errno = EINVAL; @@ -1977,6 +2098,7 @@ namespace msvcrt { } unsigned long WIN_ENTRY wcsspn(const uint16_t *str1, const uint16_t *str2) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcsspn(%p, %p)\n", str1, str2); if (!str1 || !str2) { return 0; @@ -1999,11 +2121,13 @@ namespace msvcrt { } long WIN_ENTRY _wtol(const uint16_t *str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_wtol(%p)\n", str); return wstrtol(str, nullptr, 10); } int WIN_ENTRY _wcsupr_s(uint16_t *str, size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_wcsupr_s(%p, %zu)\n", str, size); if (!str || size == 0) { return EINVAL; @@ -2020,6 +2144,7 @@ namespace msvcrt { } int WIN_ENTRY _wcslwr_s(uint16_t *str, size_t size) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_wcslwr_s(%p, %zu)\n", str, size); if (!str || size == 0) { return EINVAL; @@ -2036,11 +2161,13 @@ namespace msvcrt { } wint_t WIN_ENTRY towlower(wint_t ch) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("towlower(%d)\n", ch); return static_cast(std::towlower(static_cast(ch))); } unsigned int WIN_ENTRY _mbctolower(unsigned int ch) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_mbctolower(%u)\n", ch); if (ch <= 0xFF) { unsigned char byte = static_cast(ch); @@ -2051,28 +2178,33 @@ namespace msvcrt { } int WIN_ENTRY toupper(int ch) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("toupper(%d)\n", ch); return std::toupper(ch); } int WIN_ENTRY tolower(int ch) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("tolower(%d)\n", ch); return std::tolower(ch); } int WIN_ENTRY _ftime64_s(void *timeb) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _ftime64_s(%p)\n", timeb); (void)timeb; return 0; } int WIN_ENTRY _crt_debugger_hook(int value) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _crt_debugger_hook(%d)\n", value); (void)value; return 0; } int WIN_ENTRY _configthreadlocale(int mode) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_configthreadlocale(mode=%d)\n", mode); static int currentMode = 0; int previous = currentMode; @@ -2088,11 +2220,13 @@ namespace msvcrt { } void WIN_ENTRY __setusermatherr(void* handler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: __setusermatherr(handler=%p)\n", handler); (void)handler; } void WIN_ENTRY _cexit() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_cexit()\n"); std::fflush(nullptr); } @@ -2105,6 +2239,7 @@ namespace msvcrt { } int WIN_ENTRY vfprintf(FILE *stream, const char *format, va_list args) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("vfprintf(stream=%p, format=%s, args=%p)\n", stream, format, args); if (!format || !stream) { errno = EINVAL; @@ -2123,6 +2258,7 @@ namespace msvcrt { } int WIN_ENTRY fprintf(FILE *stream, const char *format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fprintf(%p, %s, ...)\n", stream, format); va_list args; va_start(args, format); @@ -2132,6 +2268,7 @@ namespace msvcrt { } int WIN_ENTRY fputc(int ch, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fputc(%d, %p)\n", ch, stream); if (!stream) { errno = EINVAL; @@ -2146,6 +2283,7 @@ namespace msvcrt { } size_t WIN_ENTRY fwrite(const void *buffer, size_t size, size_t count, FILE *stream) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("fwrite(%p, %zu, %zu, %p)\n", buffer, size, count, stream); if (!buffer || !stream) { errno = EINVAL; @@ -2160,16 +2298,19 @@ namespace msvcrt { } char *WIN_ENTRY strerror(int errnum) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("strerror(%d)\n", errnum); return std::strerror(errnum); } char *WIN_ENTRY strchr(const char *str, int character) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("strchr(%s, %d)\n", str, character); return const_cast(std::strchr(str, character)); } struct lconv *WIN_ENTRY localeconv() { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("localeconv()\n"); return std::localeconv(); } @@ -2177,6 +2318,7 @@ namespace msvcrt { using SignalHandler = void (*)(int); SignalHandler WIN_ENTRY signal(int sig, SignalHandler handler) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("signal(%d, %p)\n", sig, handler); if (sig != SIGABRT && sig != SIGFPE && sig != SIGILL && sig != SIGINT && sig != SIGSEGV && sig != SIGTERM) { @@ -2188,6 +2330,7 @@ namespace msvcrt { } size_t WIN_ENTRY wcslen(const uint16_t *str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcslen(%p)\n", str); return wstrlen(str); } @@ -2198,10 +2341,12 @@ namespace msvcrt { } void WIN_ENTRY abort() { + WIN_API_SEGMENT_GUARD(); abort_and_log("abort"); } int WIN_ENTRY atoi(const char *str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("atoi(%s)\n", str); if (!str) { errno = EINVAL; @@ -2211,36 +2356,43 @@ namespace msvcrt { } int WIN_ENTRY _amsg_exit(int reason) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_amsg_exit(%d)\n", reason); abort_and_log("_amsg_exit"); return reason; } void WIN_ENTRY _invoke_watson(const uint16_t *, const uint16_t *, const uint16_t *, unsigned int, uintptr_t) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_invoke_watson(...)\n"); abort_and_log("_invoke_watson"); } void WIN_ENTRY terminateShim() { + WIN_API_SEGMENT_GUARD(); abort_and_log("terminate"); } int WIN_ENTRY _purecall() { + WIN_API_SEGMENT_GUARD(); abort_and_log("_purecall"); return 0; } int WIN_ENTRY _except_handler4_common(void *, void *, void *, void *) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _except_handler4_common\n"); return 0; } long WIN_ENTRY _XcptFilter(unsigned long code, void *) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _XcptFilter(%lu)\n", code); return 0; } int WIN_ENTRY _get_wpgmptr(uint16_t **pValue) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_get_wpgmptr(%p)\n", pValue); if (!pValue) { return 22; @@ -2263,6 +2415,7 @@ namespace msvcrt { } char** WIN_ENTRY __p__pgmptr() { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("__p__pgmptr()\n"); _pgmptr = const_cast(wibo::guestExecutablePath.c_str()); return &_pgmptr; @@ -2270,6 +2423,7 @@ namespace msvcrt { int WIN_ENTRY _wsplitpath_s(const uint16_t * path, uint16_t * drive, size_t driveNumberOfElements, uint16_t *dir, size_t dirNumberOfElements, uint16_t * fname, size_t nameNumberOfElements, uint16_t * ext, size_t extNumberOfElements){ + WIN_API_SEGMENT_GUARD(); if(!path){ return 22; } @@ -2322,6 +2476,7 @@ namespace msvcrt { } int WIN_ENTRY wcscat_s(uint16_t *strDestination, size_t numberOfElements, const uint16_t *strSource){ + WIN_API_SEGMENT_GUARD(); std::string dst_str = wideStringToString(strDestination); std::string src_str = wideStringToString(strSource); DEBUG_LOG("wcscat_s %s %d %s", dst_str.c_str(), numberOfElements, src_str.c_str()); @@ -2343,6 +2498,7 @@ namespace msvcrt { } uint16_t* WIN_ENTRY _wcsdup(const uint16_t *strSource){ + WIN_API_SEGMENT_GUARD(); // std::string src_str = wideStringToString(strSource); // DEBUG_LOG("_wcsdup: %s", src_str.c_str()); if(!strSource) return nullptr; @@ -2361,6 +2517,7 @@ namespace msvcrt { } int WIN_ENTRY _waccess_s(const uint16_t* path, int mode){ + WIN_API_SEGMENT_GUARD(); std::string original = wideStringToString(path); DEBUG_LOG("_waccess_s %s\n", original.c_str()); std::filesystem::path host = files::pathFromWindows(original.c_str()); @@ -2375,10 +2532,12 @@ namespace msvcrt { } void* WIN_ENTRY memset(void *s, int c, size_t n){ + WIN_API_SEGMENT_GUARD(); return std::memset(s, c, n); } int WIN_ENTRY wcsncpy_s(uint16_t *strDest, size_t numberOfElements, const uint16_t *strSource, size_t count){ + WIN_API_SEGMENT_GUARD(); std::string src_str = wideStringToString(strSource); DEBUG_LOG("wcsncpy_s(%p, %zu, %p, %zu)\n", strDest, numberOfElements, strSource, count); @@ -2401,6 +2560,7 @@ namespace msvcrt { } int WIN_ENTRY wcsncat_s(uint16_t *strDest, size_t numberOfElements, const uint16_t *strSource, size_t count){ + WIN_API_SEGMENT_GUARD(); std::string dst_str = wideStringToString(strDest); std::string src_str = wideStringToString(strSource); DEBUG_LOG("wscncat_s(%p, %zu, %p, %zu)\n", strDest, numberOfElements, strSource, count); @@ -2424,6 +2584,7 @@ namespace msvcrt { } int WIN_ENTRY _itow_s(int value, uint16_t *buffer, size_t size, int radix){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_itow_s(%d, %p, %zu, %d)\n", value, buffer, size, radix); if (!buffer || size == 0) return 22; assert(radix == 10); // only base 10 supported for now @@ -2442,11 +2603,13 @@ namespace msvcrt { } int WIN_ENTRY _wtoi(const uint16_t* str) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_wtoi(%p)\n", str); return wstrtol(str, nullptr, 10); } int WIN_ENTRY _ltoa_s(long value, char *buffer, size_t sizeInChars, int radix) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_ltoa_s(%ld, %p, %zu, %d)\n", value, buffer, sizeInChars, radix); if (!buffer || sizeInChars == 0) { return 22; @@ -2484,6 +2647,7 @@ namespace msvcrt { } int WIN_ENTRY wcscpy_s(uint16_t *dest, size_t dest_size, const uint16_t *src){ + WIN_API_SEGMENT_GUARD(); std::string src_str = wideStringToString(src); VERBOSE_LOG("wcscpy_s(%p, %zu, %p)\n", dest, dest_size, src); if (!dest || !src || dest_size == 0) { @@ -2500,6 +2664,7 @@ namespace msvcrt { } int WIN_ENTRY swprintf_s(uint16_t *buffer, size_t sizeOfBuffer, const uint16_t *format, ...) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("swprintf_s(%p, %zu, %p, ...)\n", buffer, sizeOfBuffer, format); if (!buffer || sizeOfBuffer == 0 || !format) { errno = EINVAL; @@ -2527,6 +2692,7 @@ namespace msvcrt { } int WIN_ENTRY swscanf_s(const uint16_t *buffer, const uint16_t *format, ...) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("swscanf_s(%p, %p, ...)\n", buffer, format); if (!buffer || !format) { errno = EINVAL; @@ -2550,26 +2716,31 @@ namespace msvcrt { } int* WIN_ENTRY _get_osfhandle(int fd){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: _get_osfhandle(%d)\n", fd); return (int*)fd; } int WIN_ENTRY _write(int fd, const void* buffer, unsigned int count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_write(fd=%d, buffer=%p, count=%u)\n", fd, buffer, count); return (int)write(fd, buffer, count); } void WIN_ENTRY exit(int status) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("exit(%d)\n", status); _Exit(status); } int WIN_ENTRY wcsncmp(const uint16_t *string1, const uint16_t *string2, size_t count) { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcsncmp(%p, %p, %zu)\n", string1, string2, count); return wstrncmp(string1, string2, count); } int WIN_ENTRY _vswprintf_c_l(uint16_t* buffer, size_t size, const uint16_t* format, ...) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_vswprintf_c_l(%p, %zu, %p, ...)\n", buffer, size, format); if (!buffer || !format || size == 0) return -1; @@ -2602,36 +2773,43 @@ namespace msvcrt { } const uint16_t* WIN_ENTRY wcsstr( const uint16_t *dest, const uint16_t *src ){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcsstr(%p, %p)\n", dest, src); return wstrstr(dest, src); } int WIN_ENTRY iswspace(uint32_t w){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("iswspace(%u)\n", w); return std::iswspace(w); } int WIN_ENTRY iswdigit(uint32_t w){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("iswdigit(%u)\n", w); return std::iswdigit(w); } const uint16_t* WIN_ENTRY wcschr(const uint16_t* str, uint16_t c){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcschr(%p, %u)\n", str, c); return wstrchr(str, c); } const uint16_t* WIN_ENTRY wcsrchr(const uint16_t *str, uint16_t c){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcsrchr(%p, %u)\n", str, c); return wstrrchr(str, c); } unsigned long WIN_ENTRY wcstoul(const uint16_t *strSource, uint16_t **endptr, int base){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("wcstoul(%p, %p, %d)\n", strSource, endptr, base); return wstrtoul(strSource, endptr, base); } FILE* WIN_ENTRY _wfsopen(const uint16_t* filename, const uint16_t* mode, int shflag){ + WIN_API_SEGMENT_GUARD(); if (!filename || !mode) return nullptr; std::string fname_str = wideStringToString(filename); std::string mode_str = wideStringToString(mode); @@ -2642,6 +2820,7 @@ namespace msvcrt { } int WIN_ENTRY puts(const char *str) { + WIN_API_SEGMENT_GUARD(); if (!str) { str = "(null)"; } @@ -2654,11 +2833,13 @@ namespace msvcrt { } int WIN_ENTRY fclose(FILE* stream){ + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("fclose(%p)\n", stream); return ::fclose(stream); } int WIN_ENTRY _flushall(){ + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("_flushall()\n"); int count = 0; @@ -2670,11 +2851,13 @@ namespace msvcrt { } int* WIN_ENTRY _errno() { + WIN_API_SEGMENT_GUARD(); VERBOSE_LOG("_errno()\n"); return &errno; } intptr_t WIN_ENTRY _wspawnvp(int mode, const uint16_t* cmdname, const uint16_t* const * argv) { + WIN_API_SEGMENT_GUARD(); if (!cmdname || !argv) { errno = EINVAL; return -1; @@ -2723,6 +2906,7 @@ namespace msvcrt { } intptr_t WIN_ENTRY _spawnvp(int mode, const char *cmdname, const char * const *argv) { + WIN_API_SEGMENT_GUARD(); if (!cmdname || !argv) { errno = EINVAL; return -1; @@ -2770,12 +2954,14 @@ namespace msvcrt { } int WIN_ENTRY _wunlink(const uint16_t *filename){ + WIN_API_SEGMENT_GUARD(); std::string str = wideStringToString(filename); DEBUG_LOG("_wunlink(%s)\n", str.c_str()); return unlink(str.c_str()); } uint16_t* WIN_ENTRY _wfullpath(uint16_t* absPath, const uint16_t* relPath, size_t maxLength){ + WIN_API_SEGMENT_GUARD(); std::string relPathStr = wideStringToString(relPath); DEBUG_LOG("_wfullpath(%s, %zu)\n", relPathStr.c_str(), maxLength); if(!relPath) return nullptr; diff --git a/dll/ntdll.cpp b/dll/ntdll.cpp index b71dbaa..f5c4c41 100644 --- a/dll/ntdll.cpp +++ b/dll/ntdll.cpp @@ -123,6 +123,7 @@ namespace ntdll { NTSTATUS WIN_FUNC NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("NtReadFile(%p, %p, %p, %p, %p, %p, %u, %p, %p) ", FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, Buffer, Length, ByteOffset, Key); (void)ApcRoutine; @@ -180,6 +181,7 @@ NTSTATUS WIN_FUNC NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE Ap NTSTATUS WIN_FUNC NtAllocateVirtualMemory(HANDLE ProcessHandle, PVOID *BaseAddress, ULONG_PTR ZeroBits, PSIZE_T RegionSize, ULONG AllocationType, ULONG Protect) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("NtAllocateVirtualMemory(%p, %p, %lu, %p, %lu, %lu) ", ProcessHandle, BaseAddress, ZeroBits, RegionSize, AllocationType, Protect); assert(ProcessHandle == (HANDLE)-1); @@ -218,6 +220,7 @@ NTSTATUS WIN_FUNC NtAllocateVirtualMemory(HANDLE ProcessHandle, PVOID *BaseAddre NTSTATUS WIN_FUNC NtProtectVirtualMemory(HANDLE ProcessHandle, PVOID *BaseAddress, PSIZE_T NumberOfBytesToProtect, ULONG NewAccessProtection, PULONG OldAccessProtection) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("NtProtectVirtualMemory(%p, %p, %p, %lu, %p) ", ProcessHandle, BaseAddress, NumberOfBytesToProtect, NewAccessProtection, OldAccessProtection); assert(ProcessHandle == (HANDLE)-1); @@ -257,6 +260,7 @@ NTSTATUS WIN_FUNC NtProtectVirtualMemory(HANDLE ProcessHandle, PVOID *BaseAddres } NTSTATUS WIN_FUNC RtlGetVersion(PRTL_OSVERSIONINFOW lpVersionInformation) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("RtlGetVersion(%p) ", lpVersionInformation); if (!lpVersionInformation) { DEBUG_LOG("-> 0x%x\n", STATUS_INVALID_PARAMETER); @@ -288,6 +292,7 @@ NTSTATUS WIN_FUNC RtlGetVersion(PRTL_OSVERSIONINFOW lpVersionInformation) { NTSTATUS WIN_FUNC NtQueryInformationProcess(HANDLE ProcessHandle, PROCESSINFOCLASS ProcessInformationClass, PVOID ProcessInformation, ULONG ProcessInformationLength, PULONG ReturnLength) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("NtQueryInformationProcess(%p, %u, %p, %u, %p) ", ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength, ReturnLength); if (!ProcessInformation) { diff --git a/dll/ole32.cpp b/dll/ole32.cpp index 86ded3e..a2ff497 100644 --- a/dll/ole32.cpp +++ b/dll/ole32.cpp @@ -2,6 +2,7 @@ namespace ole32 { int WIN_FUNC CoInitialize(void *pvReserved) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: CoInitialize(%p)\n", pvReserved); (void) pvReserved; return 0; // S_OK @@ -21,6 +22,7 @@ namespace ole32 { const GUID *riid, void **ppv ) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("STUB: CoCreateInstance(0x%x, %p, %d, 0x%x, %p)\n", rclsid->Data1, pUnkOuter, dwClsContext, riid->Data1, *ppv); *ppv = 0; // E_POINTER is returned when ppv is NULL, which isn't true here, but returning 1 results diff --git a/dll/psapi.cpp b/dll/psapi.cpp index 24df6cf..008e3f0 100644 --- a/dll/psapi.cpp +++ b/dll/psapi.cpp @@ -4,6 +4,7 @@ namespace psapi { BOOL WIN_FUNC EnumProcessModules(HANDLE hProcess, HMODULE *lphModule, DWORD cb, DWORD *lpcbNeeded) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("EnumProcessModules(%p, %p, %u, %p)\n", hProcess, lphModule, cb, lpcbNeeded); bool recognizedHandle = false; diff --git a/dll/rpcrt4.cpp b/dll/rpcrt4.cpp index ff8a474..690206d 100644 --- a/dll/rpcrt4.cpp +++ b/dll/rpcrt4.cpp @@ -130,6 +130,7 @@ extern "C" { RPC_STATUS WIN_FUNC RpcStringBindingComposeW(RPC_WSTR objUuid, RPC_WSTR protSeq, RPC_WSTR networkAddr, RPC_WSTR endpoint, RPC_WSTR options, RPC_WSTR *stringBinding) { + WIN_API_SEGMENT_GUARD(); BindingComponents components; components.objectUuid = toU16(objUuid); components.protocolSequence = toU16(protSeq); @@ -159,6 +160,7 @@ RPC_STATUS WIN_FUNC RpcStringBindingComposeW(RPC_WSTR objUuid, RPC_WSTR protSeq, } RPC_STATUS WIN_FUNC RpcBindingFromStringBindingW(RPC_WSTR stringBinding, RPC_BINDING_HANDLE *binding) { + WIN_API_SEGMENT_GUARD(); if (!binding) { return RPC_S_INVALID_ARG; } @@ -185,6 +187,7 @@ RPC_STATUS WIN_FUNC RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE binding, RPC_WST unsigned long authnLevel, unsigned long authnSvc, RPC_AUTH_IDENTITY_HANDLE authIdentity, unsigned long authzSvc, RPC_SECURITY_QOS *securityQos) { + WIN_API_SEGMENT_GUARD(); BindingHandleData *data = getBinding(binding); if (!data) { return RPC_S_INVALID_BINDING; @@ -206,6 +209,7 @@ RPC_STATUS WIN_FUNC RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE binding, RPC_WST } RPC_STATUS WIN_FUNC RpcBindingFree(RPC_BINDING_HANDLE *binding) { + WIN_API_SEGMENT_GUARD(); if (!binding) { return RPC_S_INVALID_ARG; } @@ -224,6 +228,7 @@ RPC_STATUS WIN_FUNC RpcBindingFree(RPC_BINDING_HANDLE *binding) { } RPC_STATUS WIN_FUNC RpcStringFreeW(RPC_WSTR *string) { + WIN_API_SEGMENT_GUARD(); if (!string) { return RPC_S_INVALID_ARG; } @@ -249,7 +254,10 @@ NdrClientCall2(PMIDL_STUB_DESC stubDescriptor, PFORMAT_STRING format, ...) { return result; } -void WIN_FUNC NdrServerCall2(PRPC_MESSAGE message) { DEBUG_LOG("STUB: NdrServerCall2 message=%p\n", message); } +void WIN_FUNC NdrServerCall2(PRPC_MESSAGE message) { + WIN_API_SEGMENT_GUARD(); + DEBUG_LOG("STUB: NdrServerCall2 message=%p\n", message); +} } // extern "C" diff --git a/dll/user32.cpp b/dll/user32.cpp index 9c30d14..c3e8635 100644 --- a/dll/user32.cpp +++ b/dll/user32.cpp @@ -7,6 +7,7 @@ namespace user32 { constexpr uintptr_t kDefaultKeyboardLayout = 0x04090409; int WIN_FUNC LoadStringA(void* hInstance, unsigned int uID, char* lpBuffer, int cchBufferMax) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LoadStringA(%p, %u, %p, %d)\n", hInstance, uID, lpBuffer, cchBufferMax); if (!lpBuffer || cchBufferMax <= 0) { return 0; @@ -54,6 +55,7 @@ namespace user32 { } int WIN_FUNC LoadStringW(void* hInstance, unsigned int uID, uint16_t* lpBuffer, int cchBufferMax) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("LoadStringW(%p, %u, %p, %d)\n", hInstance, uID, lpBuffer, cchBufferMax); wibo::Executable *mod = wibo::executableFromModule((HMODULE) hInstance); if (!mod) { @@ -107,12 +109,14 @@ namespace user32 { } int WIN_FUNC MessageBoxA(void *hwnd, const char *lpText, const char *lpCaption, unsigned int uType) { + WIN_API_SEGMENT_GUARD(); printf("MESSAGE BOX: [%s] %s\n", lpCaption, lpText); fflush(stdout); return 1; } HKL WIN_FUNC GetKeyboardLayout(DWORD idThread) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetKeyboardLayout(%u)\n", idThread); (void)idThread; wibo::lastError = ERROR_SUCCESS; diff --git a/dll/vcruntime.cpp b/dll/vcruntime.cpp index 0b05314..ffc541f 100644 --- a/dll/vcruntime.cpp +++ b/dll/vcruntime.cpp @@ -2,13 +2,25 @@ namespace vcruntime { -void *WIN_ENTRY memcpy(void *dest, const void *src, size_t count) { return ::memcpy(dest, src, count); } +void *WIN_ENTRY memcpy(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); + return ::memcpy(dest, src, count); +} -void *WIN_ENTRY memset(void *dest, int ch, size_t count) { return ::memset(dest, ch, count); } +void *WIN_ENTRY memset(void *dest, int ch, size_t count) { + WIN_API_SEGMENT_GUARD(); + return ::memset(dest, ch, count); +} -int WIN_ENTRY memcmp(const void *buf1, const void *buf2, size_t count) { return ::memcmp(buf1, buf2, count); } +int WIN_ENTRY memcmp(const void *buf1, const void *buf2, size_t count) { + WIN_API_SEGMENT_GUARD(); + return ::memcmp(buf1, buf2, count); +} -void *WIN_ENTRY memmove(void *dest, const void *src, size_t count) { return ::memmove(dest, src, count); } +void *WIN_ENTRY memmove(void *dest, const void *src, size_t count) { + WIN_API_SEGMENT_GUARD(); + return ::memmove(dest, src, count); +} } // namespace vcruntime diff --git a/dll/version.cpp b/dll/version.cpp index 86a4eab..4b37f9c 100644 --- a/dll/version.cpp +++ b/dll/version.cpp @@ -206,6 +206,7 @@ static bool loadVersionResource(const char *fileName, std::vector &buff namespace version { unsigned int WIN_FUNC GetFileVersionInfoSizeA(const char *lptstrFilename, unsigned int *lpdwHandle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileVersionInfoSizeA(%s, %p)\n", lptstrFilename, lpdwHandle); if (lpdwHandle) *lpdwHandle = 0; @@ -217,6 +218,7 @@ unsigned int WIN_FUNC GetFileVersionInfoSizeA(const char *lptstrFilename, unsign } unsigned int WIN_FUNC GetFileVersionInfoA(const char *lptstrFilename, unsigned int dwHandle, unsigned int dwLen, void *lpData) { + WIN_API_SEGMENT_GUARD(); (void) dwHandle; DEBUG_LOG("GetFileVersionInfoA(%s, %u, %p)\n", lptstrFilename, dwLen, lpData); if (!lpData || dwLen == 0) { @@ -279,6 +281,7 @@ static unsigned int VerQueryValueImpl(const void *pBlock, const std::string &sub } unsigned int WIN_FUNC VerQueryValueA(const void *pBlock, const char *lpSubBlock, void **lplpBuffer, unsigned int *puLen) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("VerQueryValueA(%p, %s, %p, %p)\n", pBlock, lpSubBlock ? lpSubBlock : "(null)", lplpBuffer, puLen); if (!lpSubBlock) return 0; @@ -286,18 +289,21 @@ unsigned int WIN_FUNC VerQueryValueA(const void *pBlock, const char *lpSubBlock, } unsigned int WIN_FUNC GetFileVersionInfoSizeW(const uint16_t *lptstrFilename, unsigned int *lpdwHandle) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileVersionInfoSizeW -> "); auto narrow = wideStringToString(lptstrFilename); return GetFileVersionInfoSizeA(narrow.c_str(), lpdwHandle); } unsigned int WIN_FUNC GetFileVersionInfoW(const uint16_t *lptstrFilename, unsigned int dwHandle, unsigned int dwLen, void *lpData) { + WIN_API_SEGMENT_GUARD(); DEBUG_LOG("GetFileVersionInfoW -> "); auto narrow = wideStringToString(lptstrFilename); return GetFileVersionInfoA(narrow.c_str(), dwHandle, dwLen, lpData); } unsigned int WIN_FUNC VerQueryValueW(const void *pBlock, const uint16_t *lpSubBlock, void **lplpBuffer, unsigned int *puLen) { + WIN_API_SEGMENT_GUARD(); if (!lpSubBlock) return 0; auto narrow = wideStringToString(lpSubBlock); diff --git a/src/common.h b/src/common.h index f7edc24..953404e 100644 --- a/src/common.h +++ b/src/common.h @@ -235,6 +235,10 @@ struct TIB { char reserved1[0x14]; PEB *peb; char reserved2[0x1000]; + uint16_t hostFsSelector; + uint16_t hostGsSelector; + uint8_t hostSegmentsValid; + uint8_t hostSegmentsPadding[5]; }; namespace wibo { @@ -251,6 +255,21 @@ extern uint16_t tibSelector; extern int tibEntryNumber; extern PEB *processPeb; +class WinApiSegmentScope { +public: + WinApiSegmentScope(); + ~WinApiSegmentScope(); + WinApiSegmentScope(const WinApiSegmentScope &) = delete; + WinApiSegmentScope &operator=(const WinApiSegmentScope &) = delete; + +private: + uint16_t previousFs_; + uint16_t previousGs_; + bool restore_; +}; + +#define WIN_API_SEGMENT_GUARD() wibo::WinApiSegmentScope _wiboSegmentScopeGuard + TIB *allocateTib(); void initializeTibStackInfo(TIB *tib); bool installTibForCurrentThread(TIB *tib); diff --git a/src/main.cpp b/src/main.cpp index 2426801..954174d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -347,6 +347,14 @@ int main(int argc, char **argv) { return 1; } + uint16_t hostFsSelector = 0; + uint16_t hostGsSelector = 0; + asm volatile("mov %%fs, %0" : "=r"(hostFsSelector)); + asm volatile("mov %%gs, %0" : "=r"(hostGsSelector)); + tib.hostFsSelector = hostFsSelector; + tib.hostGsSelector = hostGsSelector; + tib.hostSegmentsValid = 1; + // Determine the guest program name auto guestArgs = wibo::splitCommandLine(cmdLine.c_str()); std::string programName; @@ -483,6 +491,10 @@ int main(int argc, char **argv) { // Invoke the damn thing asm("movw %0, %%fs; call *%1" : : "r"(wibo::tibSelector), "r"(entryPoint)); + if (tib.hostSegmentsValid) { + asm volatile("movw %0, %%fs" : : "r"(tib.hostFsSelector) : "memory"); + asm volatile("movw %0, %%gs" : : "r"(tib.hostGsSelector) : "memory"); + } DEBUG_LOG("We came back\n"); wibo::shutdownModuleRegistry(); diff --git a/src/winapi_segments.cpp b/src/winapi_segments.cpp new file mode 100644 index 0000000..c85b564 --- /dev/null +++ b/src/winapi_segments.cpp @@ -0,0 +1,36 @@ +#include "common.h" + +#include + +namespace wibo { + +WinApiSegmentScope::WinApiSegmentScope() + : previousFs_(0), previousGs_(0), restore_(false) { + asm volatile("mov %%fs, %0" : "=r"(previousFs_)); + asm volatile("mov %%gs, %0" : "=r"(previousGs_)); + if (previousFs_ == wibo::tibSelector) { + constexpr size_t kHostFsOffset = offsetof(TIB, hostFsSelector); + constexpr size_t kHostGsOffset = offsetof(TIB, hostGsSelector); + constexpr size_t kHostValidOffset = offsetof(TIB, hostSegmentsValid); + unsigned char hostValid = 0; + asm volatile("movb %%fs:%c1, %0" : "=r"(hostValid) : "i"(kHostValidOffset)); + if (hostValid) { + uint16_t hostFs = 0; + uint16_t hostGs = 0; + asm volatile("movw %%fs:%c1, %0" : "=r"(hostFs) : "i"(kHostFsOffset)); + asm volatile("movw %%fs:%c1, %0" : "=r"(hostGs) : "i"(kHostGsOffset)); + asm volatile("movw %0, %%fs" : : "r"(hostFs) : "memory"); + asm volatile("movw %0, %%gs" : : "r"(hostGs) : "memory"); + restore_ = true; + } + } +} + +WinApiSegmentScope::~WinApiSegmentScope() { + if (restore_) { + asm volatile("movw %0, %%fs" : : "r"(previousFs_) : "memory"); + asm volatile("movw %0, %%gs" : : "r"(previousGs_) : "memory"); + } +} + +} // namespace wibo