decompals/wibo
1
0
Fork 0
mirror of https://github.com/decompals/wibo.git synced 2025-10-15 14:45:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Save/restore fs/gs segments when re-entering host code

Browse Source
This commit is contained in:
Luke Street 2025-10-05 13:58:40 -06:00
parent 04516b246c
commit cd7baffc5e
44 changed files with 669 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -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

1
dll/advapi32/processthreadsapi.cpp
View File

@ -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;

18
dll/advapi32/securitybaseapi.cpp
View File

@ -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;

5
dll/advapi32/winbase.cpp
View File

@ -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;

7
dll/advapi32/wincrypt.cpp
View File

@ -205,6 +205,7 @@ HCRYPTHASH hashHandleFromObject(HashObject *hash) { return static_cast<HCRYPTHAS
namespace advapi32 {
BOOL WIN_FUNC CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: CryptReleaseContext(%p, %u)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(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<void *>(static_cast<uintptr_t>(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<void *>(static_cast<uintptr_t>(hProv)), Algid,
reinterpret_cast<void *>(static_cast<uintptr_t>(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<void *>(static_cast<uintptr_t>(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<void *>(static_cast<uintptr_t>(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<void *>(static_cast<uintptr_t>(hHash)));
auto *hash = hashObjectFromHandle(hHash);
if (!hash) {

9
dll/advapi32/winreg.cpp
View File

@ -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<uint16_t> 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;

1
dll/bcrypt.cpp
View File

@ -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;

45
dll/crt.cpp
View File

@ -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;

1
dll/kernel32/debugapi.cpp
View File

@ -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;

7
dll/kernel32/errhandlingapi.cpp
View File

@ -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<PVOID>(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;

4
dll/kernel32/fibersapi.cpp
View File

@ -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;

39
dll/kernel32/fileapi.cpp
View File

@ -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<FileObject>(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<long>(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<FileObject>(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<FileObject>(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<FileObject>(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<FileObject>(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<FileObject>(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;

2
dll/kernel32/handleapi.cpp
View File

@ -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;

26
dll/kernel32/heapapi.cpp
View File

@ -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<HeapObject>(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<int>(HeapInformationClass),
HeapInformation, HeapInformationLength);
auto record = wibo::handles().getAs<HeapObject>(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<HeapObject>(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<HeapObject>(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<HeapObject>(hHeap);
@ -274,16 +281,18 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return static_cast<SIZE_T>(-1);
}
// if (!mi_heap_check_owned(record->heap, const_cast<LPVOID>(lpMem))) {
// wibo::lastError = ERROR_INVALID_PARAMETER;
// return static_cast<SIZE_T>(-1);
// }
if (!mi_heap_check_owned(record->heap, const_cast<LPVOID>(lpMem))) {
DEBUG_LOG("HeapSize: block %p not owned by heap %p\n", lpMem, record->heap);
wibo::lastError = ERROR_INVALID_PARAMETER;
return static_cast<SIZE_T>(-1);
}
size_t size = mi_usable_size(lpMem);
wibo::lastError = ERROR_SUCCESS;
return static_cast<SIZE_T>(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;

5
dll/kernel32/interlockedapi.cpp
View File

@ -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<long>(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<long>(Exchange),
static_cast<long>(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;

1
dll/kernel32/ioapiset.cpp
View File

@ -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) {

17
dll/kernel32/libloaderapi.cpp
View File

@ -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) {

11
dll/kernel32/memoryapi.cpp
View File

@ -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<MappingObject> 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<uintptr_t>(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;

1
dll/kernel32/namedpipeapi.cpp
View File

@ -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;

12
dll/kernel32/processenv.cpp
View File

@ -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<LPSTR>(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;

38
dll/kernel32/processthreadsapi.cpp
View File

@ -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<void *>(static_cast<uintptr_t>(-1)));
return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(-1));
}
DWORD WIN_FUNC GetCurrentProcessId() {
WIN_API_SEGMENT_GUARD();
DWORD pid = static_cast<DWORD>(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<DWORD>(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<HANDLE>(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<unsigned long>(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<unsigned long>(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<int>(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<HANDLE>(static_cast<uintptr_t>(-1))) {
exit(static_cast<int>(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<ThreadObject>(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 : "<null>",
lpCommandLine ? lpCommandLine : "<null>", lpProcessAttributes, lpThreadAttributes, bInheritHandles,
dwCreationFlags, lpEnvironment, lpCurrentDirectory ? lpCurrentDirectory : "<none>", 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;

2
dll/kernel32/profileapi.cpp
View File

@ -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;

4
dll/kernel32/stringapiset.cpp
View File

@ -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;

41
dll/kernel32/synchapi.cpp
View File

@ -38,11 +38,13 @@ void makeWideNameFromAnsi(LPCSTR ansiName, std::vector<uint16_t> &outWide) {
namespace kernel32 {
void WIN_FUNC Sleep(DWORD dwMilliseconds) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("Sleep(%u)\n", dwMilliseconds);
usleep(static_cast<useconds_t>(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<int>(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<uint16_t> 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<MutexObject>(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<int>(bManualReset),
static_cast<int>(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<uint16_t> 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<uint16_t> 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<EventObject>(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<EventObject>(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;
}

7
dll/kernel32/sysinfoapi.cpp
View File

@ -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;

7
dll/kernel32/timezoneapi.cpp
View File

@ -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;

42
dll/kernel32/winbase.cpp
View File

@ -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<size_t>(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<size_t>(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<size_t>(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<size_t>(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<size_t>(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<size_t>(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<LPVOID>(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,

11
dll/kernel32/wincon.cpp
View File

@ -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<const void *>(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;

16
dll/kernel32/winnls.cpp
View File

@ -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<std::pair<uint8_t, uint8_t>> 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;

1
dll/kernel32/winnt.cpp
View File

@ -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");
}

3
dll/kernel32/wow64apiset.cpp
View File

@ -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;

2
dll/lmgr.cpp
View File

@ -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;
}

1
dll/mscoree.cpp
View File

@ -3,6 +3,7 @@
namespace mscoree {
void WIN_FUNC CorExitProcess(int exitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CorExitProcess(%i)\n", exitCode);
exit(exitCode);
}

186
dll/msvcrt.cpp
View File

File diff suppressed because it is too large Load Diff

5
dll/ntdll.cpp
View File

@ -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) {

2
dll/ole32.cpp
View File

@ -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

1
dll/psapi.cpp
View File

@ -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;

10
dll/rpcrt4.cpp
View File

@ -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"

4
dll/user32.cpp
View File

@ -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;

20
dll/vcruntime.cpp
View File

@ -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

6
dll/version.cpp
View File

@ -206,6 +206,7 @@ static bool loadVersionResource(const char *fileName, std::vector<uint8_t> &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);

19
src/common.h
View File

@ -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);

12
src/main.cpp
View File

@ -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();

36
src/winapi_segments.cpp Normal file
View File

@ -0,0 +1,36 @@
#include "common.h"
#include <cstddef>
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