decompals/wibo
1
0
Fork 0
mirror of https://github.com/decompals/wibo.git synced 2025-10-16 07:05:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Dont set ERROR_SUCCESS generally

Browse Source 
Turns out we should only be setting this in a select few cases.
This commit is contained in:
Luke Street 2025-10-06 00:03:08 -06:00
parent 01ed50c4b4
commit 166b9036fd
30 changed files with 61 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dll/advapi32/processthreadsapi.cpp
View File

@ -29,7 +29,6 @@ BOOL WIN_FUNC OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDL
} }
auto token = make_pin<TokenObject>(std::move(obj), DesiredAccess); auto token = make_pin<TokenObject>(std::move(obj), DesiredAccess);
*TokenHandle = wibo::handles().alloc(std::move(token), 0, 0); *TokenHandle = wibo::handles().alloc(std::move(token), 0, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

22
dll/advapi32/securitybaseapi.cpp
View File

@ -129,7 +129,6 @@ BOOL WIN_FUNC InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision) {
pAcl->AclSize = static_cast<WORD>(sizeof(ACL)); pAcl->AclSize = static_cast<WORD>(sizeof(ACL));
pAcl->AceCount = 0; pAcl->AceCount = 0;
pAcl->Sbz2 = static_cast<WORD>(nAclLength); pAcl->Sbz2 = static_cast<WORD>(nAclLength);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -199,7 +198,6 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa
std::memcpy(&ace->SidStart, sid, sidLen); std::memcpy(&ace->SidStart, sid, sidLen);
pAcl->AceCount = static_cast<WORD>(pAcl->AceCount + 1); pAcl->AceCount = static_cast<WORD>(pAcl->AceCount + 1);
pAcl->AclSize = static_cast<WORD>(used + aceSize); pAcl->AclSize = static_cast<WORD>(used + aceSize);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -223,7 +221,6 @@ BOOL WIN_FUNC FindFirstFreeAce(PACL pAcl, LPVOID *pAce) {
} }
*pAce = reinterpret_cast<BYTE *>(pAcl) + used; *pAce = reinterpret_cast<BYTE *>(pAcl) + used;
pAcl->AclSize = static_cast<WORD>(std::max<size_t>(pAcl->AclSize, used)); pAcl->AclSize = static_cast<WORD>(std::max<size_t>(pAcl->AclSize, used));
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -253,7 +250,6 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
if (lpbDaclDefaulted) { if (lpbDaclDefaulted) {
*lpbDaclDefaulted = FALSE; *lpbDaclDefaulted = FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (pDacl) { if (pDacl) {
@ -262,7 +258,6 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
if (lpbDaclDefaulted) { if (lpbDaclDefaulted) {
*lpbDaclDefaulted = (pSecurityDescriptor->Control & SE_DACL_DEFAULTED) ? TRUE : FALSE; *lpbDaclDefaulted = (pSecurityDescriptor->Control & SE_DACL_DEFAULTED) ? TRUE : FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -278,7 +273,6 @@ PSID_IDENTIFIER_AUTHORITY WIN_FUNC GetSidIdentifierAuthority(PSID pSid) {
wibo::lastError = ERROR_INVALID_SID; wibo::lastError = ERROR_INVALID_SID;
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<PSID_IDENTIFIER_AUTHORITY>(&sid->IdentifierAuthority); return reinterpret_cast<PSID_IDENTIFIER_AUTHORITY>(&sid->IdentifierAuthority);
} }
@ -294,7 +288,6 @@ PUCHAR WIN_FUNC GetSidSubAuthorityCount(PSID pSid) {
wibo::lastError = ERROR_INVALID_SID; wibo::lastError = ERROR_INVALID_SID;
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return &sid->SubAuthorityCount; return &sid->SubAuthorityCount;
} }
@ -310,7 +303,6 @@ PDWORD WIN_FUNC GetSidSubAuthority(PSID pSid, DWORD nSubAuthority) {
wibo::lastError = ERROR_INVALID_SID; wibo::lastError = ERROR_INVALID_SID;
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return &sid->SubAuthority[nSubAuthority]; return &sid->SubAuthority[nSubAuthority];
} }
@ -318,7 +310,6 @@ BOOL WIN_FUNC ImpersonateLoggedOnUser(HANDLE hToken) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: ImpersonateLoggedOnUser(%p)\n", hToken); DEBUG_LOG("STUB: ImpersonateLoggedOnUser(%p)\n", hToken);
(void)hToken; (void)hToken;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -342,7 +333,6 @@ BOOL WIN_FUNC DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, voi
auto newToken = auto newToken =
make_pin<TokenObject>(existing->obj.clone(), dwDesiredAccess == 0 ? existing->desiredAccess : dwDesiredAccess); make_pin<TokenObject>(existing->obj.clone(), dwDesiredAccess == 0 ? existing->desiredAccess : dwDesiredAccess);
*phNewToken = wibo::handles().alloc(std::move(newToken), 0, 0); *phNewToken = wibo::handles().alloc(std::move(newToken), 0, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -360,7 +350,6 @@ BOOL WIN_FUNC CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pS
return FALSE; return FALSE;
} }
std::memcpy(pDestinationSid, pSourceSid, required); std::memcpy(pDestinationSid, pSourceSid, required);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -382,7 +371,6 @@ BOOL WIN_FUNC InitializeSid(PSID sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAutho
if (nSubAuthorityCount > 0) { if (nSubAuthorityCount > 0) {
std::memset(sidStruct->SubAuthority, 0, sizeof(DWORD) * nSubAuthorityCount); std::memset(sidStruct->SubAuthority, 0, sizeof(DWORD) * nSubAuthorityCount);
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -406,7 +394,6 @@ BOOL WIN_FUNC EqualSid(PSID pSid1, PSID pSid2) {
if (equal && sid1->SubAuthorityCount > 0) { if (equal && sid1->SubAuthorityCount > 0) {
equal = std::memcmp(sid1->SubAuthority, sid2->SubAuthority, sizeof(DWORD) * sid1->SubAuthorityCount) == 0; equal = std::memcmp(sid1->SubAuthority, sid2->SubAuthority, sizeof(DWORD) * sid1->SubAuthorityCount) == 0;
} }
wibo::lastError = ERROR_SUCCESS;
return equal ? TRUE : FALSE; return equal ? TRUE : FALSE;
} }
@ -424,7 +411,6 @@ BOOL WIN_FUNC SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION Securi
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -442,7 +428,6 @@ BOOL WIN_FUNC InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescrip
pSecurityDescriptor->Group = nullptr; pSecurityDescriptor->Group = nullptr;
pSecurityDescriptor->Sacl = nullptr; pSecurityDescriptor->Sacl = nullptr;
pSecurityDescriptor->Dacl = nullptr; pSecurityDescriptor->Dacl = nullptr;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -465,7 +450,6 @@ BOOL WIN_FUNC SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
pSecurityDescriptor->Dacl = nullptr; pSecurityDescriptor->Dacl = nullptr;
} }
pSecurityDescriptor->Control = control; pSecurityDescriptor->Control = control;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -501,7 +485,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
} }
tokenUser->User.SidPtr = sid; tokenUser->User.SidPtr = sid;
tokenUser->User.Attributes = 0; tokenUser->User.Attributes = 0;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenStatistics) { if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenStatistics) {
@ -518,7 +501,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
stats->tokenId.LowPart = 1; stats->tokenId.LowPart = 1;
stats->authenticationId.LowPart = 1; stats->authenticationId.LowPart = 1;
stats->modifiedId.LowPart = 1; stats->modifiedId.LowPart = 1;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenElevation) { if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenElevation) {
@ -529,7 +511,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
return FALSE; return FALSE;
} }
*reinterpret_cast<DWORD *>(TokenInformation) = 0; // not elevated *reinterpret_cast<DWORD *>(TokenInformation) = 0; // not elevated
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenPrimaryGroup) { if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenPrimaryGroup) {
@ -546,7 +527,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
return FALSE; return FALSE;
} }
groupInfo->PrimaryGroup = sid; groupInfo->PrimaryGroup = sid;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
wibo::lastError = ERROR_NOT_SUPPORTED; wibo::lastError = ERROR_NOT_SUPPORTED;
@ -564,7 +544,6 @@ BOOL WIN_FUNC AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivilege
(void)BufferLength; (void)BufferLength;
(void)PreviousState; (void)PreviousState;
(void)ReturnLength; (void)ReturnLength;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -581,7 +560,6 @@ BOOL WIN_FUNC SetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

5
dll/advapi32/winbase.cpp
View File

@ -111,7 +111,6 @@ BOOL WIN_FUNC LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPD
*peUse = SidTypeWellKnownGroup; *peUse = SidTypeWellKnownGroup;
*cchName = requiredAccount; *cchName = requiredAccount;
*cchReferencedDomainName = requiredDomain; *cchReferencedDomainName = requiredDomain;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -127,7 +126,6 @@ BOOL WIN_FUNC LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lp
std::string normalized = normalizePrivilegeName(lpName); std::string normalized = normalizePrivilegeName(lpName);
LUID luid = lookupOrGeneratePrivilegeLuid(normalized); LUID luid = lookupOrGeneratePrivilegeLuid(normalized);
*lpLuid = luid; *lpLuid = luid;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -143,7 +141,6 @@ BOOL WIN_FUNC LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID
std::string normalized = normalizePrivilegeName(ansiName); std::string normalized = normalizePrivilegeName(ansiName);
LUID luid = lookupOrGeneratePrivilegeLuid(normalized); LUID luid = lookupOrGeneratePrivilegeLuid(normalized);
*lpLuid = luid; *lpLuid = luid;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -163,7 +160,6 @@ BOOL WIN_FUNC GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer) {
} }
std::memcpy(lpBuffer, name, needed); std::memcpy(lpBuffer, name, needed);
*pcbBuffer = static_cast<DWORD>(needed); *pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -182,7 +178,6 @@ BOOL WIN_FUNC GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer) {
} }
std::memcpy(lpBuffer, kAccountSystem, needed * sizeof(WCHAR)); std::memcpy(lpBuffer, kAccountSystem, needed * sizeof(WCHAR));
*pcbBuffer = static_cast<DWORD>(needed); *pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

12
dll/advapi32/wincrypt.cpp
View File

@ -211,7 +211,6 @@ BOOL WIN_FUNC CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags) {
DEBUG_LOG("STUB: CryptReleaseContext(%p, %u)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hProv)), dwFlags); DEBUG_LOG("STUB: CryptReleaseContext(%p, %u)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hProv)), dwFlags);
(void)hProv; (void)hProv;
(void)dwFlags; (void)dwFlags;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -227,7 +226,6 @@ BOOL WIN_FUNC CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPC
return FALSE; return FALSE;
} }
*phProv = static_cast<HCRYPTPROV>(reinterpret_cast<uintptr_t>(&dummyProvider)); *phProv = static_cast<HCRYPTPROV>(reinterpret_cast<uintptr_t>(&dummyProvider));
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -246,7 +244,6 @@ BOOL WIN_FUNC CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) {
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -277,7 +274,6 @@ BOOL WIN_FUNC CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DW
hash->data.clear(); hash->data.clear();
hash->digest.clear(); hash->digest.clear();
*phHash = hashHandleFromObject(hash); *phHash = hashHandleFromObject(hash);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -299,7 +295,6 @@ BOOL WIN_FUNC CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLe
hash->digestComputed = false; hash->digestComputed = false;
hash->digest.clear(); hash->digest.clear();
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -321,7 +316,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
DWORD required = sizeof(ALG_ID); DWORD required = sizeof(ALG_ID);
if (!pbData) { if (!pbData) {
*pdwDataLen = required; *pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (*pdwDataLen < required) { if (*pdwDataLen < required) {
@ -331,7 +325,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
} }
memcpy(pbData, &hash->algid, required); memcpy(pbData, &hash->algid, required);
*pdwDataLen = required; *pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
case HP_HASHSIZE: { case HP_HASHSIZE: {
@ -349,7 +342,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
} }
if (!pbData) { if (!pbData) {
*pdwDataLen = sizeof(DWORD); *pdwDataLen = sizeof(DWORD);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (*pdwDataLen < sizeof(DWORD)) { if (*pdwDataLen < sizeof(DWORD)) {
@ -359,7 +351,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
} }
memcpy(pbData, &size, sizeof(DWORD)); memcpy(pbData, &size, sizeof(DWORD));
*pdwDataLen = sizeof(DWORD); *pdwDataLen = sizeof(DWORD);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
case HP_HASHVAL: { case HP_HASHVAL: {
@ -370,7 +361,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
DWORD required = static_cast<DWORD>(hash->digest.size()); DWORD required = static_cast<DWORD>(hash->digest.size());
if (!pbData) { if (!pbData) {
*pdwDataLen = required; *pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (*pdwDataLen < required) { if (*pdwDataLen < required) {
@ -380,7 +370,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
} }
memcpy(pbData, hash->digest.data(), required); memcpy(pbData, hash->digest.data(), required);
*pdwDataLen = required; *pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
default: default:
@ -398,7 +387,6 @@ BOOL WIN_FUNC CryptDestroyHash(HCRYPTHASH hHash) {
return FALSE; return FALSE;
} }
delete hash; delete hash;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

6
dll/advapi32/winreg.cpp
View File

@ -186,13 +186,11 @@ LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LP
} }
if (targetingBase) { if (targetingBase) {
*phkResult = hKey; *phkResult = hKey;
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
auto obj = make_pin<RegistryKeyObject>(std::move(targetPath)); auto obj = make_pin<RegistryKeyObject>(std::move(targetPath));
auto handle = wibo::handles().alloc(std::move(obj), 0, 0); auto handle = wibo::handles().alloc(std::move(obj), 0, 0);
*phkResult = reinterpret_cast<HKEY>(handle); *phkResult = reinterpret_cast<HKEY>(handle);
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -264,14 +262,12 @@ LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REG
if (!lpSubKey || lpSubKey[0] == 0) { if (!lpSubKey || lpSubKey[0] == 0) {
if (baseHandle->predefined) { if (baseHandle->predefined) {
*phkResult = hKey; *phkResult = hKey;
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
} }
auto obj = make_pin<RegistryKeyObject>(std::move(targetPath)); auto obj = make_pin<RegistryKeyObject>(std::move(targetPath));
auto handle = wibo::handles().alloc(std::move(obj), 0, 0); auto handle = wibo::handles().alloc(std::move(obj), 0, 0);
*phkResult = reinterpret_cast<HKEY>(handle); *phkResult = reinterpret_cast<HKEY>(handle);
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -383,7 +379,6 @@ LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("RegCloseKey(%p)\n", hKey); DEBUG_LOG("RegCloseKey(%p)\n", hKey);
if (isPredefinedKeyHandle(hKey)) { if (isPredefinedKeyHandle(hKey)) {
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
auto obj = wibo::handles().getAs<RegistryKeyObject>(hKey); auto obj = wibo::handles().getAs<RegistryKeyObject>(hKey);
@ -391,7 +386,6 @@ LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) {
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return ERROR_INVALID_HANDLE; return ERROR_INVALID_HANDLE;
} }
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }

1
dll/kernel32/debugapi.cpp
View File

@ -9,7 +9,6 @@ namespace kernel32 {
BOOL WIN_FUNC IsDebuggerPresent() { BOOL WIN_FUNC IsDebuggerPresent() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: IsDebuggerPresent()\n"); DEBUG_LOG("STUB: IsDebuggerPresent()\n");
wibo::lastError = ERROR_SUCCESS;
return FALSE; return FALSE;
} }

8
dll/kernel32/fibersapi.cpp
View File

@ -27,7 +27,7 @@ DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) {
} }
} }
DEBUG_LOG(" -> -1\n"); DEBUG_LOG(" -> -1\n");
wibo::lastError = 1; wibo::lastError = FLS_OUT_OF_INDEXES;
return FLS_OUT_OF_INDEXES; return FLS_OUT_OF_INDEXES;
} }
@ -38,7 +38,7 @@ BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) {
g_flsValuesUsed[dwFlsIndex] = false; g_flsValuesUsed[dwFlsIndex] = false;
return TRUE; return TRUE;
} else { } else {
wibo::lastError = 1; wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE; return FALSE;
} }
} }
@ -52,7 +52,7 @@ PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) {
// See https://learn.microsoft.com/en-us/windows/win32/api/fibersapi/nf-fibersapi-flsgetvalue // See https://learn.microsoft.com/en-us/windows/win32/api/fibersapi/nf-fibersapi-flsgetvalue
wibo::lastError = ERROR_SUCCESS; wibo::lastError = ERROR_SUCCESS;
} else { } else {
wibo::lastError = 1; wibo::lastError = ERROR_INVALID_PARAMETER;
} }
// DEBUG_LOG(" -> %p\n", result); // DEBUG_LOG(" -> %p\n", result);
return result; return result;
@ -65,7 +65,7 @@ BOOL WIN_FUNC FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) {
g_flsValues[dwFlsIndex] = lpFlsData; g_flsValues[dwFlsIndex] = lpFlsData;
return TRUE; return TRUE;
} else { } else {
wibo::lastError = 1; wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE; return FALSE;
} }
} }

69
dll/kernel32/fileapi.cpp
View File

@ -111,8 +111,7 @@ bool computeFullPath(const std::string &input, FullPathInfo &outInfo) {
std::error_code ec; std::error_code ec;
std::filesystem::path absPath = std::filesystem::absolute(hostPath, ec); std::filesystem::path absPath = std::filesystem::absolute(hostPath, ec);
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
kernel32::setLastErrorFromErrno();
return false; return false;
} }
@ -266,7 +265,6 @@ bool tryOpenConsoleDevice(DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCrea
outHandle = INVALID_HANDLE_VALUE; outHandle = INVALID_HANDLE_VALUE;
return true; return true;
} }
wibo::lastError = ERROR_SUCCESS;
return true; return true;
} }
@ -306,19 +304,16 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
if (endsWith(pathStr, "/license.dat")) { if (endsWith(pathStr, "/license.dat")) {
DEBUG_LOG("MWCC license override\n"); DEBUG_LOG("MWCC license override\n");
wibo::lastError = ERROR_SUCCESS;
return FILE_ATTRIBUTE_NORMAL; return FILE_ATTRIBUTE_NORMAL;
} }
std::error_code ec; std::error_code ec;
auto status = std::filesystem::status(path, ec); auto status = std::filesystem::status(path, ec);
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastErrorFromErrno();
return INVALID_FILE_ATTRIBUTES; return INVALID_FILE_ATTRIBUTES;
} }
wibo::lastError = ERROR_SUCCESS;
switch (status.type()) { switch (status.type()) {
case std::filesystem::file_type::regular: case std::filesystem::file_type::regular:
DEBUG_LOG("File exists\n"); DEBUG_LOG("File exists\n");
@ -348,7 +343,6 @@ UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeA(%s)\n", lpRootPathName ? lpRootPathName : "(null)"); DEBUG_LOG("STUB: GetDriveTypeA(%s)\n", lpRootPathName ? lpRootPathName : "(null)");
(void)lpRootPathName; (void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
return DRIVE_FIXED; return DRIVE_FIXED;
} }
@ -356,7 +350,6 @@ UINT WIN_FUNC GetDriveTypeW(LPCWSTR lpRootPathName) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeW(%p)\n", lpRootPathName); DEBUG_LOG("STUB: GetDriveTypeW(%p)\n", lpRootPathName);
(void)lpRootPathName; (void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
return DRIVE_FIXED; return DRIVE_FIXED;
} }
@ -386,7 +379,6 @@ BOOL WIN_FUNC GetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuf
lpFileSystemNameBuffer[copyLen] = '\0'; lpFileSystemNameBuffer[copyLen] = '\0';
} }
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -418,7 +410,6 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB
lpFileSystemNameBuffer[copyLen] = 0; lpFileSystemNameBuffer[copyLen] = 0;
} }
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -448,7 +439,6 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("WriteFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, DEBUG_LOG("WriteFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten,
lpOverlapped); lpOverlapped);
wibo::lastError = ERROR_SUCCESS;
HandleMeta meta{}; HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta); auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@ -514,7 +504,6 @@ BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) {
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -523,7 +512,6 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("ReadFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, DEBUG_LOG("ReadFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead,
lpOverlapped); lpOverlapped);
wibo::lastError = ERROR_SUCCESS;
HandleMeta meta{}; HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta); auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@ -806,8 +794,6 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
if ((dwCreationDisposition == OPEN_ALWAYS && existedBefore) || if ((dwCreationDisposition == OPEN_ALWAYS && existedBefore) ||
(dwCreationDisposition == CREATE_ALWAYS && existedBefore)) { (dwCreationDisposition == CREATE_ALWAYS && existedBefore)) {
wibo::lastError = ERROR_ALREADY_EXISTS; wibo::lastError = ERROR_ALREADY_EXISTS;
} else {
wibo::lastError = ERROR_SUCCESS;
} }
DEBUG_LOG("-> %p (createdNew=%d, truncate=%d)\n", handle, createdNew ? 1 : 0, truncateExisting ? 1 : 0); DEBUG_LOG("-> %p (createdNew=%d, truncate=%d)\n", handle, createdNew ? 1 : 0, truncateExisting ? 1 : 0);
@ -837,12 +823,11 @@ BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) {
} }
std::string path = files::pathFromWindows(lpFileName); std::string path = files::pathFromWindows(lpFileName);
DEBUG_LOG("DeleteFileA(%s) -> %s\n", lpFileName, path.c_str()); DEBUG_LOG("DeleteFileA(%s) -> %s\n", lpFileName, path.c_str());
if (unlink(path.c_str()) == 0) { if (unlink(path.c_str()) != 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
}
return TRUE;
} }
BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) { BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) {
@ -872,17 +857,14 @@ BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) {
return FALSE; return FALSE;
} }
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastErrorFromErrno();
return FALSE; return FALSE;
} }
std::filesystem::rename(fromPath, toPath, ec); std::filesystem::rename(fromPath, toPath, ec);
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -935,7 +917,6 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan
if (lpDistanceToMoveHigh) { if (lpDistanceToMoveHigh) {
*lpDistanceToMoveHigh = static_cast<LONG>(static_cast<uint64_t>(position) >> 32); *lpDistanceToMoveHigh = static_cast<LONG>(static_cast<uint64_t>(position) >> 32);
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(static_cast<uint64_t>(position) & 0xFFFFFFFFu); return static_cast<DWORD>(static_cast<uint64_t>(position) & 0xFFFFFFFFu);
} }
@ -1005,7 +986,6 @@ BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) {
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1018,12 +998,11 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri
} }
std::string path = files::pathFromWindows(lpPathName); std::string path = files::pathFromWindows(lpPathName);
DEBUG_LOG("CreateDirectoryA(%s, %p)\n", path.c_str(), lpSecurityAttributes); DEBUG_LOG("CreateDirectoryA(%s, %p)\n", path.c_str(), lpSecurityAttributes);
if (mkdir(path.c_str(), 0755) == 0) { if (mkdir(path.c_str(), 0755) != 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
}
return TRUE;
} }
BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) { BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
@ -1034,12 +1013,11 @@ BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
} }
std::string path = files::pathFromWindows(lpPathName); std::string path = files::pathFromWindows(lpPathName);
DEBUG_LOG("RemoveDirectoryA(%s)\n", path.c_str()); DEBUG_LOG("RemoveDirectoryA(%s)\n", path.c_str());
if (rmdir(path.c_str()) == 0) { if (rmdir(path.c_str()) != 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
}
return TRUE;
} }
BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) { BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
@ -1050,7 +1028,6 @@ BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
return FALSE; return FALSE;
} }
DEBUG_LOG("STUB: SetFileAttributesA(%s, %u)\n", lpFileName, dwFileAttributes); DEBUG_LOG("STUB: SetFileAttributesA(%s, %u)\n", lpFileName, dwFileAttributes);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1077,7 +1054,6 @@ DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
if (lpFileSizeHigh) { if (lpFileSizeHigh) {
*lpFileSizeHigh = static_cast<DWORD>(uSize >> 32); *lpFileSizeHigh = static_cast<DWORD>(uSize >> 32);
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(uSize & 0xFFFFFFFFu); return static_cast<DWORD>(uSize & 0xFFFFFFFFu);
} }
@ -1120,7 +1096,6 @@ BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lp
wibo::lastError = ERROR_INVALID_PARAMETER; wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1144,7 +1119,6 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
bool changeAccess = !shouldIgnoreFileTimeParam(lpLastAccessTime); bool changeAccess = !shouldIgnoreFileTimeParam(lpLastAccessTime);
bool changeWrite = !shouldIgnoreFileTimeParam(lpLastWriteTime); bool changeWrite = !shouldIgnoreFileTimeParam(lpLastWriteTime);
if (!changeAccess && !changeWrite) { if (!changeAccess && !changeWrite) {
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
struct stat st{}; struct stat st{};
@ -1192,7 +1166,6 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
if (!shouldIgnoreFileTimeParam(lpCreationTime) && lpCreationTime) { if (!shouldIgnoreFileTimeParam(lpCreationTime) && lpCreationTime) {
DEBUG_LOG("SetFileTime: creation time not supported\n"); DEBUG_LOG("SetFileTime: creation time not supported\n");
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1231,7 +1204,6 @@ BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMAT
lpFileInformation->nNumberOfLinks = 0; lpFileInformation->nNumberOfLinks = 0;
lpFileInformation->nFileIndexHigh = 0; lpFileInformation->nFileIndexHigh = 0;
lpFileInformation->nFileIndexLow = 0; lpFileInformation->nFileIndexLow = 0;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1250,7 +1222,6 @@ DWORD WIN_FUNC GetFileType(HANDLE hFile) {
DEBUG_LOG("-> fstat error\n"); DEBUG_LOG("-> fstat error\n");
return FILE_TYPE_UNKNOWN; return FILE_TYPE_UNKNOWN;
} }
wibo::lastError = ERROR_SUCCESS;
DWORD type = FILE_TYPE_UNKNOWN; DWORD type = FILE_TYPE_UNKNOWN;
if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode) || S_ISBLK(st.st_mode)) { if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode) || S_ISBLK(st.st_mode)) {
type = FILE_TYPE_DISK; type = FILE_TYPE_DISK;
@ -1314,7 +1285,6 @@ DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lp
} }
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(pathLen); return static_cast<DWORD>(pathLen);
} }
@ -1368,7 +1338,6 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR
} }
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(wideLen - 1); return static_cast<DWORD>(wideLen - 1);
} }
@ -1389,7 +1358,6 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
} }
strcpy(lpszShortPath, absStr.c_str()); strcpy(lpszShortPath, absStr.c_str());
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -1411,7 +1379,6 @@ DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWO
return required; return required;
} }
wstrncpy(lpszShortPath, absStrW.data(), len + 1); wstrncpy(lpszShortPath, absStrW.data(), len + 1);
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(len); return static_cast<DWORD>(len);
} }
@ -1454,7 +1421,6 @@ UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uU
DEBUG_LOG(" -> %s\n", str.c_str()); DEBUG_LOG(" -> %s\n", str.c_str());
strncpy(lpTempFileName, str.c_str(), MAX_PATH); strncpy(lpTempFileName, str.c_str(), MAX_PATH);
lpTempFileName[MAX_PATH - 1] = '\0'; lpTempFileName[MAX_PATH - 1] = '\0';
wibo::lastError = ERROR_SUCCESS;
return uUnique; return uUnique;
} }
@ -1482,7 +1448,6 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
DEBUG_LOG(" -> %s\n", path); DEBUG_LOG(" -> %s\n", path);
strncpy(lpBuffer, path, nBufferLength); strncpy(lpBuffer, path, nBufferLength);
lpBuffer[nBufferLength - 1] = '\0'; lpBuffer[nBufferLength - 1] = '\0';
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(len); return static_cast<DWORD>(len);
} }
@ -1503,7 +1468,6 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
setCommonFindDataFields(*lpFindFileData); setCommonFindDataFields(*lpFindFileData);
if (status.type() == std::filesystem::file_type::regular) { if (status.type() == std::filesystem::file_type::regular) {
setFindFileDataFromPath(hostPath, *lpFindFileData); setFindFileDataFromPath(hostPath, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return kPseudoFindHandle; return kPseudoFindHandle;
} }
@ -1525,7 +1489,6 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
} }
setFindFileDataFromPath(match, *lpFindFileData); setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HANDLE>(handle); return reinterpret_cast<HANDLE>(handle);
} }
@ -1547,7 +1510,6 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
setCommonFindDataFields(*lpFindFileData); setCommonFindDataFields(*lpFindFileData);
if (status.type() == std::filesystem::file_type::regular) { if (status.type() == std::filesystem::file_type::regular) {
setFindFileDataFromPath(hostPath, *lpFindFileData); setFindFileDataFromPath(hostPath, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return kPseudoFindHandle; return kPseudoFindHandle;
} }
@ -1569,7 +1531,6 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
} }
setFindFileDataFromPath(match, *lpFindFileData); setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HANDLE>(handle); return reinterpret_cast<HANDLE>(handle);
} }
@ -1610,7 +1571,6 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
} }
setFindFileDataFromPath(match, *lpFindFileData); setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1639,7 +1599,6 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
} }
setFindFileDataFromPath(match, *lpFindFileData); setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1647,7 +1606,6 @@ BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("FindClose(%p)\n", hFindFile); DEBUG_LOG("FindClose(%p)\n", hFindFile);
if (isPseudoHandle(hFindFile) || hFindFile == nullptr) { if (isPseudoHandle(hFindFile) || hFindFile == nullptr) {
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1657,7 +1615,6 @@ BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
return FALSE; return FALSE;
} }
delete handle; delete handle;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

4
dll/kernel32/handleapi.cpp
View File

@ -42,14 +42,12 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
auto handle = wibo::handles().alloc(std::move(po), 0, 0); auto handle = wibo::handles().alloc(std::move(po), 0, 0);
DEBUG_LOG("DuplicateHandle: created process handle for current process -> %p\n", handle); DEBUG_LOG("DuplicateHandle: created process handle for current process -> %p\n", handle);
*lpTargetHandle = handle; *lpTargetHandle = handle;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} else if (isPseudoCurrentThreadHandle(hSourceHandle)) { } else if (isPseudoCurrentThreadHandle(hSourceHandle)) {
auto th = make_pin<ThreadObject>(pthread_self()); auto th = make_pin<ThreadObject>(pthread_self());
auto handle = wibo::handles().alloc(std::move(th), 0, 0); auto handle = wibo::handles().alloc(std::move(th), 0, 0);
DEBUG_LOG("DuplicateHandle: created thread handle for current thread -> %p\n", handle); DEBUG_LOG("DuplicateHandle: created thread handle for current thread -> %p\n", handle);
*lpTargetHandle = handle; *lpTargetHandle = handle;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -58,7 +56,6 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -69,7 +66,6 @@ BOOL WIN_FUNC CloseHandle(HANDLE hObject) {
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

13
dll/kernel32/heapapi.cpp
View File

@ -56,7 +56,6 @@ LPVOID heapAllocFromRecord(HeapObject *record, DWORD dwFlags, SIZE_T dwBytes) {
if (isExecutableHeap(record)) { if (isExecutableHeap(record)) {
kernel32::tryMarkExecutable(mem); kernel32::tryMarkExecutable(mem);
} }
wibo::lastError = ERROR_SUCCESS;
return mem; return mem;
} }
@ -99,7 +98,6 @@ HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaxim
record->isProcessHeap = false; record->isProcessHeap = false;
HANDLE handle = wibo::handles().alloc(std::move(record), 0, 0); HANDLE handle = wibo::handles().alloc(std::move(record), 0, 0);
wibo::lastError = ERROR_SUCCESS;
return handle; return handle;
} }
@ -118,14 +116,12 @@ BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) {
} }
mi_heap_destroy(record->heap); mi_heap_destroy(record->heap);
record->heap = nullptr; record->heap = nullptr;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
HANDLE WIN_FUNC GetProcessHeap() { HANDLE WIN_FUNC GetProcessHeap() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
ensureProcessHeapInitialized(); ensureProcessHeapInitialized();
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("GetProcessHeap() -> %p\n", g_processHeapHandle); DEBUG_LOG("GetProcessHeap() -> %p\n", g_processHeapHandle);
return g_processHeapHandle; return g_processHeapHandle;
} }
@ -152,11 +148,9 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI
return FALSE; return FALSE;
} }
record->compatibility = *static_cast<ULONG *>(HeapInformation); record->compatibility = *static_cast<ULONG *>(HeapInformation);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
case HeapEnableTerminationOnCorruption: case HeapEnableTerminationOnCorruption:
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
case HeapOptimizeResources: case HeapOptimizeResources:
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED; wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
@ -205,7 +199,6 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
if (lpMem == nullptr) { if (lpMem == nullptr) {
void *alloc = heapAllocFromRecord(record.get(), dwFlags, dwBytes); void *alloc = heapAllocFromRecord(record.get(), dwFlags, dwBytes);
DEBUG_LOG("-> %p (alloc)\n", alloc); DEBUG_LOG("-> %p (alloc)\n", alloc);
wibo::lastError = ERROR_SUCCESS;
return alloc; return alloc;
} }
// if (!mi_heap_check_owned(record->heap, lpMem)) { // if (!mi_heap_check_owned(record->heap, lpMem)) {
@ -224,7 +217,6 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
if (!inplaceOnly) { if (!inplaceOnly) {
mi_free(lpMem); mi_free(lpMem);
DEBUG_LOG("-> NULL (freed)\n"); DEBUG_LOG("-> NULL (freed)\n");
wibo::lastError = ERROR_SUCCESS;
return nullptr; return nullptr;
} }
DEBUG_LOG("-> NULL (zero size with in-place flag)\n"); DEBUG_LOG("-> NULL (zero size with in-place flag)\n");
@ -241,7 +233,6 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
return nullptr; return nullptr;
} }
DEBUG_LOG("-> %p (in-place)\n", lpMem); DEBUG_LOG("-> %p (in-place)\n", lpMem);
wibo::lastError = ERROR_SUCCESS;
return lpMem; return lpMem;
} }
@ -260,7 +251,6 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
if (isExecutableHeap(record.get())) { if (isExecutableHeap(record.get())) {
tryMarkExecutable(ret); tryMarkExecutable(ret);
} }
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("-> %p\n", ret); DEBUG_LOG("-> %p\n", ret);
return ret; return ret;
} }
@ -289,7 +279,6 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
return static_cast<SIZE_T>(-1); return static_cast<SIZE_T>(-1);
} }
size_t size = mi_usable_size(lpMem); size_t size = mi_usable_size(lpMem);
wibo::lastError = ERROR_SUCCESS;
return static_cast<SIZE_T>(size); return static_cast<SIZE_T>(size);
} }
@ -298,7 +287,6 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
DEBUG_LOG("HeapFree(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem); DEBUG_LOG("HeapFree(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem);
(void)dwFlags; (void)dwFlags;
if (lpMem == nullptr) { if (lpMem == nullptr) {
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
auto record = wibo::handles().getAs<HeapObject>(hHeap); auto record = wibo::handles().getAs<HeapObject>(hHeap);
@ -320,7 +308,6 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
} }
mi_free(lpMem); mi_free(lpMem);
DEBUG_LOG("-> SUCCESS\n"); DEBUG_LOG("-> SUCCESS\n");
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

1
dll/kernel32/ioapiset.cpp
View File

@ -30,7 +30,6 @@ BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWO
} }
if (status == STATUS_SUCCESS) { if (status == STATUS_SUCCESS) {
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
if (status == STATUS_END_OF_FILE) { if (status == STATUS_END_OF_FILE) {

7
dll/kernel32/libloaderapi.cpp
View File

@ -48,7 +48,6 @@ BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) {
wibo::lastError = ERROR_INVALID_HANDLE; wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -60,7 +59,6 @@ HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) {
wibo::lastError = ERROR_MOD_NOT_FOUND; wibo::lastError = ERROR_MOD_NOT_FOUND;
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return module->handle; return module->handle;
} }
@ -107,7 +105,6 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
wibo::lastError = ERROR_INSUFFICIENT_BUFFER; wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
return nSize; return nSize;
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(copyLen); return static_cast<DWORD>(copyLen);
} }
@ -149,7 +146,6 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
wibo::lastError = ERROR_INSUFFICIENT_BUFFER; wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
return nSize; return nSize;
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(copyLen); return static_cast<DWORD>(copyLen);
} }
@ -239,7 +235,6 @@ HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) {
// lastError is set by loadModule // lastError is set by loadModule
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return info->handle; return info->handle;
} }
@ -293,8 +288,6 @@ FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
DEBUG_LOG("-> %p\n", result); DEBUG_LOG("-> %p\n", result);
if (!result) { if (!result) {
wibo::lastError = ERROR_PROC_NOT_FOUND; wibo::lastError = ERROR_PROC_NOT_FOUND;
} else {
wibo::lastError = ERROR_SUCCESS;
} }
return result; return result;
} }

26
dll/kernel32/memoryapi.cpp
View File

@ -511,7 +511,6 @@ HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap
mapping->maxSize = size; mapping->maxSize = size;
} }
wibo::lastError = ERROR_SUCCESS;
return wibo::handles().alloc(std::move(mapping), 0, 0); return wibo::handles().alloc(std::move(mapping), 0, 0);
} }
@ -658,7 +657,6 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
std::lock_guard guard(g_viewInfoMutex); std::lock_guard guard(g_viewInfoMutex);
g_viewInfo.emplace(view.viewBase, std::move(view)); g_viewInfo.emplace(view.viewBase, std::move(view));
} }
wibo::lastError = ERROR_SUCCESS;
return viewPtr; return viewPtr;
} }
@ -708,7 +706,6 @@ BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) {
if (length != 0) { if (length != 0) {
munmap(base, length); munmap(base, length);
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -766,10 +763,9 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
int advice = MADV_DONTNEED; int advice = MADV_DONTNEED;
#endif #endif
if (madvise(reinterpret_cast<void *>(start), length, advice) != 0) { if (madvise(reinterpret_cast<void *>(start), length, advice) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<LPVOID>(start); return reinterpret_cast<LPVOID>(start);
} }
@ -828,7 +824,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
result = alignedReserve(length, prot, flags); result = alignedReserve(length, prot, flags);
} }
if (result == MAP_FAILED) { if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return nullptr; return nullptr;
} }
if (reinterpret_cast<uintptr_t>(result) >= 0x80000000) { if (reinterpret_cast<uintptr_t>(result) >= 0x80000000) {
@ -843,7 +839,6 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
allocation.allocationProtect = flProtect; allocation.allocationProtect = flProtect;
allocation.pageProtect.assign(length / pageSize, commit ? flProtect : 0); allocation.pageProtect.assign(length / pageSize, commit ? flProtect : 0);
g_virtualAllocations[actualBase] = std::move(allocation); g_virtualAllocations[actualBase] = std::move(allocation);
wibo::lastError = ERROR_SUCCESS;
return result; return result;
} }
@ -892,12 +887,11 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
void *result = mmap(reinterpret_cast<void *>(run.first), run.second, translateProtect(flProtect), void *result = mmap(reinterpret_cast<void *>(run.first), run.second, translateProtect(flProtect),
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
if (result == MAP_FAILED) { if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return nullptr; return nullptr;
} }
markCommitted(*region, run.first, run.second, flProtect); markCommitted(*region, run.first, run.second, flProtect);
} }
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("VirtualAlloc commit success -> %p\n", reinterpret_cast<void *>(start)); DEBUG_LOG("VirtualAlloc commit success -> %p\n", reinterpret_cast<void *>(start));
return reinterpret_cast<LPVOID>(start); return reinterpret_cast<LPVOID>(start);
} }
@ -945,10 +939,9 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
g_virtualAllocations.erase(exact); g_virtualAllocations.erase(exact);
lk.unlock(); lk.unlock();
if (munmap(lpAddress, length) != 0) { if (munmap(lpAddress, length) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -987,11 +980,10 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
void *result = mmap(reinterpret_cast<void *>(start), length, PROT_NONE, void *result = mmap(reinterpret_cast<void *>(start), length, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_NORESERVE, -1, 0); MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_NORESERVE, -1, 0);
if (result == MAP_FAILED) { if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
markDecommitted(region, start, length); markDecommitted(region, start, length);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1040,7 +1032,7 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
int prot = translateProtect(flNewProtect); int prot = translateProtect(flNewProtect);
if (mprotect(reinterpret_cast<void *>(start), end - start, prot) != 0) { if (mprotect(reinterpret_cast<void *>(start), end - start, prot) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
for (size_t i = 0; i < pageCount; ++i) { for (size_t i = 0; i < pageCount; ++i) {
@ -1051,7 +1043,6 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
if (lpflOldProtect) { if (lpflOldProtect) {
*lpflOldProtect = previousProtect; *lpflOldProtect = previousProtect;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1077,17 +1068,14 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
MEMORY_BASIC_INFORMATION info{}; MEMORY_BASIC_INFORMATION info{};
if (moduleRegionForAddress(pageBase, info)) { if (moduleRegionForAddress(pageBase, info)) {
*lpBuffer = info; *lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
return sizeof(MEMORY_BASIC_INFORMATION); return sizeof(MEMORY_BASIC_INFORMATION);
} }
if (mappedViewRegionForAddress(request, pageBase, info)) { if (mappedViewRegionForAddress(request, pageBase, info)) {
*lpBuffer = info; *lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
return sizeof(MEMORY_BASIC_INFORMATION); return sizeof(MEMORY_BASIC_INFORMATION);
} }
if (virtualAllocationRegionForAddress(pageBase, info)) { if (virtualAllocationRegionForAddress(pageBase, info)) {
*lpBuffer = info; *lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
return sizeof(MEMORY_BASIC_INFORMATION); return sizeof(MEMORY_BASIC_INFORMATION);
} }
@ -1107,7 +1095,6 @@ BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorking
} }
*lpMinimumWorkingSetSize = 32 * 1024 * 1024; // 32 MiB stub *lpMinimumWorkingSetSize = 32 * 1024 * 1024; // 32 MiB stub
*lpMaximumWorkingSetSize = 128 * 1024 * 1024; // 128 MiB stub *lpMaximumWorkingSetSize = 128 * 1024 * 1024; // 128 MiB stub
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1118,7 +1105,6 @@ BOOL WIN_FUNC SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T dwMinimumWorkingS
(void)hProcess; (void)hProcess;
(void)dwMinimumWorkingSetSize; (void)dwMinimumWorkingSetSize;
(void)dwMaximumWorkingSetSize; (void)dwMaximumWorkingSetSize;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

1
dll/kernel32/namedpipeapi.cpp
View File

@ -63,7 +63,6 @@ BOOL WIN_FUNC CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRI
writeObj->shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE; writeObj->shareAccess = FILE_SHARE_READ | FILE_SHARE_WRITE;
*hReadPipe = wibo::handles().alloc(std::move(readObj), FILE_GENERIC_READ, 0); *hReadPipe = wibo::handles().alloc(std::move(readObj), FILE_GENERIC_READ, 0);
*hWritePipe = wibo::handles().alloc(std::move(writeObj), FILE_GENERIC_WRITE, 0); *hWritePipe = wibo::handles().alloc(std::move(writeObj), FILE_GENERIC_WRITE, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

14
dll/kernel32/processenv.cpp
View File

@ -44,14 +44,12 @@ namespace kernel32 {
LPSTR WIN_FUNC GetCommandLineA() { LPSTR WIN_FUNC GetCommandLineA() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetCommandLineA() -> %s\n", wibo::commandLine.c_str()); DEBUG_LOG("GetCommandLineA() -> %s\n", wibo::commandLine.c_str());
wibo::lastError = ERROR_SUCCESS;
return const_cast<LPSTR>(wibo::commandLine.c_str()); return const_cast<LPSTR>(wibo::commandLine.c_str());
} }
LPWSTR WIN_FUNC GetCommandLineW() { LPWSTR WIN_FUNC GetCommandLineW() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetCommandLineW() -> %s\n", wideStringToString(wibo::commandLineW.data()).c_str()); DEBUG_LOG("GetCommandLineW() -> %s\n", wideStringToString(wibo::commandLineW.data()).c_str());
wibo::lastError = ERROR_SUCCESS;
return wibo::commandLineW.data(); return wibo::commandLineW.data();
} }
@ -97,7 +95,6 @@ LPCH WIN_FUNC GetEnvironmentStrings() {
} }
*ptr = 0; *ptr = 0;
wibo::lastError = ERROR_SUCCESS;
return buffer; return buffer;
} }
@ -133,7 +130,6 @@ LPWCH WIN_FUNC GetEnvironmentStringsW() {
} }
*ptr = 0; *ptr = 0;
wibo::lastError = ERROR_SUCCESS;
return buffer; return buffer;
} }
@ -145,7 +141,6 @@ BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) {
return FALSE; return FALSE;
} }
free(penv); free(penv);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -157,7 +152,6 @@ BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) {
return FALSE; return FALSE;
} }
free(penv); free(penv);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -177,7 +171,6 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz
const std::string &finalValue = converted.empty() ? std::string(rawValue) : converted; const std::string &finalValue = converted.empty() ? std::string(rawValue) : converted;
DWORD len = static_cast<DWORD>(finalValue.size()); DWORD len = static_cast<DWORD>(finalValue.size());
if (nSize == 0) { if (nSize == 0) {
wibo::lastError = ERROR_SUCCESS;
return len + 1; return len + 1;
} }
if (!lpBuffer) { if (!lpBuffer) {
@ -185,11 +178,9 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz
return 0; return 0;
} }
if (nSize <= len) { if (nSize <= len) {
wibo::lastError = ERROR_SUCCESS;
return len + 1; return len + 1;
} }
memcpy(lpBuffer, finalValue.c_str(), len + 1); memcpy(lpBuffer, finalValue.c_str(), len + 1);
wibo::lastError = ERROR_SUCCESS;
return len; return len;
} }
@ -211,7 +202,6 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS
auto wideValue = stringToWideString(finalValue.c_str()); auto wideValue = stringToWideString(finalValue.c_str());
DWORD required = static_cast<DWORD>(wideValue.size()); DWORD required = static_cast<DWORD>(wideValue.size());
if (nSize == 0) { if (nSize == 0) {
wibo::lastError = ERROR_SUCCESS;
return required; return required;
} }
if (!lpBuffer) { if (!lpBuffer) {
@ -219,11 +209,9 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS
return 0; return 0;
} }
if (nSize < required) { if (nSize < required) {
wibo::lastError = ERROR_SUCCESS;
return required; return required;
} }
std::copy(wideValue.begin(), wideValue.end(), lpBuffer); std::copy(wideValue.begin(), wideValue.end(), lpBuffer);
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -241,7 +229,6 @@ BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) {
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
std::string hostValue = convertEnvValueToHost(lpName, lpValue); std::string hostValue = convertEnvValueToHost(lpName, lpValue);
@ -251,7 +238,6 @@ BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) {
setLastErrorFromErrno(); setLastErrorFromErrno();
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

21
dll/kernel32/processthreadsapi.cpp
View File

@ -252,7 +252,6 @@ BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffini
*lpProcessAffinityMask = processMask; *lpProcessAffinityMask = processMask;
*lpSystemAffinityMask = systemMask == 0 ? 1 : systemMask; *lpSystemAffinityMask = systemMask == 0 ? 1 : systemMask;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -280,7 +279,6 @@ BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinit
g_processAffinityMask = dwProcessAffinityMask & systemMask; g_processAffinityMask = dwProcessAffinityMask & systemMask;
g_processAffinityMaskInitialized = true; g_processAffinityMaskInitialized = true;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -310,7 +308,6 @@ DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffin
return 0; return 0;
} }
wibo::lastError = ERROR_SUCCESS;
return processMask; return processMask;
} }
@ -332,7 +329,6 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
return FALSE; return FALSE;
} }
if (process->signaled.load(std::memory_order_acquire)) { if (process->signaled.load(std::memory_order_acquire)) {
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
std::lock_guard lk(process->m); std::lock_guard lk(process->m);
@ -352,7 +348,6 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
} }
process->exitCode = uExitCode; process->exitCode = uExitCode;
process->forcedExitCode = true; process->forcedExitCode = true;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -365,7 +360,6 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
} }
if (isPseudoCurrentProcessHandle(hProcess)) { if (isPseudoCurrentProcessHandle(hProcess)) {
*lpExitCode = STILL_ACTIVE; *lpExitCode = STILL_ACTIVE;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
auto process = wibo::handles().getAs<ProcessObject>(hProcess); auto process = wibo::handles().getAs<ProcessObject>(hProcess);
@ -379,7 +373,6 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
exitCode = process->exitCode; exitCode = process->exitCode;
} }
*lpExitCode = exitCode; *lpExitCode = exitCode;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -390,7 +383,6 @@ DWORD WIN_FUNC TlsAlloc() {
if (!g_tlsSlotsUsed[i]) { if (!g_tlsSlotsUsed[i]) {
g_tlsSlotsUsed[i] = true; g_tlsSlotsUsed[i] = true;
g_tlsSlots[i] = nullptr; g_tlsSlots[i] = nullptr;
wibo::lastError = ERROR_SUCCESS;
return i; return i;
} }
} }
@ -407,7 +399,6 @@ BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) {
} }
g_tlsSlotsUsed[dwTlsIndex] = false; g_tlsSlotsUsed[dwTlsIndex] = false;
g_tlsSlots[dwTlsIndex] = nullptr; g_tlsSlots[dwTlsIndex] = nullptr;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -418,7 +409,6 @@ LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) {
wibo::lastError = ERROR_INVALID_PARAMETER; wibo::lastError = ERROR_INVALID_PARAMETER;
return nullptr; return nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return g_tlsSlots[dwTlsIndex]; return g_tlsSlots[dwTlsIndex];
} }
@ -430,7 +420,6 @@ BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) {
return FALSE; return FALSE;
} }
g_tlsSlots[dwTlsIndex] = lpTlsValue; g_tlsSlots[dwTlsIndex] = lpTlsValue;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -458,7 +447,6 @@ DWORD WIN_FUNC ResumeThread(HANDLE hThread) {
if (notify) { if (notify) {
obj->cv.notify_all(); obj->cv.notify_all();
} }
wibo::lastError = ERROR_SUCCESS;
return previous; return previous;
} }
@ -519,7 +507,6 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw
*lpThreadId = static_cast<DWORD>(hashed & 0xffffffffu); *lpThreadId = static_cast<DWORD>(hashed & 0xffffffffu);
} }
wibo::lastError = ERROR_SUCCESS;
return wibo::handles().alloc(std::move(obj), 0 /* TODO */, 0); return wibo::handles().alloc(std::move(obj), 0 /* TODO */, 0);
} }
@ -546,7 +533,6 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
} }
if (isPseudoCurrentThreadHandle(hThread)) { if (isPseudoCurrentThreadHandle(hThread)) {
*lpExitCode = STILL_ACTIVE; *lpExitCode = STILL_ACTIVE;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
auto obj = wibo::handles().getAs<ThreadObject>(hThread); auto obj = wibo::handles().getAs<ThreadObject>(hThread);
@ -556,7 +542,6 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
} }
std::lock_guard lk(obj->m); std::lock_guard lk(obj->m);
*lpExitCode = obj->exitCode; *lpExitCode = obj->exitCode;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -565,7 +550,6 @@ BOOL WIN_FUNC SetThreadPriority(HANDLE hThread, int nPriority) {
DEBUG_LOG("STUB: SetThreadPriority(%p, %d)\n", hThread, nPriority); DEBUG_LOG("STUB: SetThreadPriority(%p, %d)\n", hThread, nPriority);
(void)hThread; (void)hThread;
(void)nPriority; (void)nPriority;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -573,7 +557,6 @@ int WIN_FUNC GetThreadPriority(HANDLE hThread) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetThreadPriority(%p)\n", hThread); DEBUG_LOG("STUB: GetThreadPriority(%p)\n", hThread);
(void)hThread; (void)hThread;
wibo::lastError = ERROR_SUCCESS;
return 0; return 0;
} }
@ -581,7 +564,6 @@ DWORD WIN_FUNC GetPriorityClass(HANDLE hProcess) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetPriorityClass(%p)\n", hProcess); DEBUG_LOG("GetPriorityClass(%p)\n", hProcess);
(void)hProcess; (void)hProcess;
wibo::lastError = ERROR_SUCCESS;
return NORMAL_PRIORITY_CLASS; return NORMAL_PRIORITY_CLASS;
} }
@ -613,7 +595,6 @@ BOOL WIN_FUNC GetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime, FILETIME
if (getrusage(RUSAGE_THREAD, &usage) == 0) { if (getrusage(RUSAGE_THREAD, &usage) == 0) {
*lpKernelTime = fileTimeFromTimeval(usage.ru_stime); *lpKernelTime = fileTimeFromTimeval(usage.ru_stime);
*lpUserTime = fileTimeFromTimeval(usage.ru_utime); *lpUserTime = fileTimeFromTimeval(usage.ru_utime);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -621,7 +602,6 @@ BOOL WIN_FUNC GetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime, FILETIME
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &cpuTime) == 0) { if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &cpuTime) == 0) {
*lpKernelTime = fileTimeFromDuration(0); *lpKernelTime = fileTimeFromDuration(0);
*lpUserTime = fileTimeFromTimespec(cpuTime); *lpUserTime = fileTimeFromTimespec(cpuTime);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -675,7 +655,6 @@ BOOL WIN_FUNC CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSE
lpProcessInformation->dwProcessId = static_cast<DWORD>(pid); lpProcessInformation->dwProcessId = static_cast<DWORD>(pid);
lpProcessInformation->dwThreadId = 0; lpProcessInformation->dwThreadId = 0;
} }
wibo::lastError = ERROR_SUCCESS;
(void)lpProcessAttributes; (void)lpProcessAttributes;
(void)lpThreadAttributes; (void)lpThreadAttributes;
(void)bInheritHandles; (void)bInheritHandles;

2
dll/kernel32/profileapi.cpp
View File

@ -14,7 +14,6 @@ BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) {
return FALSE; return FALSE;
} }
*lpPerformanceCount = 0; *lpPerformanceCount = 0;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -26,7 +25,6 @@ BOOL WIN_FUNC QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) {
return FALSE; return FALSE;
} }
*lpFrequency = 1; *lpFrequency = 1;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

10
dll/kernel32/stringapiset.cpp
View File

@ -100,7 +100,6 @@ BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWO
(cntrl ? 0x20 : 0) | (blank ? 0x40 : 0) | (hex ? 0x80 : 0) | (alpha ? 0x100 : 0); (cntrl ? 0x20 : 0) | (blank ? 0x40 : 0) | (hex ? 0x80 : 0) | (alpha ? 0x100 : 0);
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -132,15 +131,10 @@ BOOL WIN_FUNC GetStringTypeA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int
wide.push_back(static_cast<unsigned char>(lpSrcStr[i])); wide.push_back(static_cast<unsigned char>(lpSrcStr[i]));
} }
BOOL result = TRUE;
if (length > 0) { if (length > 0) {
result = GetStringTypeW(dwInfoType, wide.data(), length, lpCharType); return GetStringTypeW(dwInfoType, wide.data(), length, lpCharType);
} else {
result = TRUE;
} }
return TRUE;
wibo::lastError = result ? ERROR_SUCCESS : wibo::lastError;
return result;
} }
} // namespace kernel32 } // namespace kernel32

8
dll/kernel32/synchapi.cpp
View File

@ -109,7 +109,6 @@ BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) {
if (notify) { if (notify) {
mu->cv.notify_one(); mu->cv.notify_one();
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -220,7 +219,6 @@ BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPr
if (lpPreviousCount) { if (lpPreviousCount) {
*lpPreviousCount = prev; *lpPreviousCount = prev;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -233,7 +231,6 @@ BOOL WIN_FUNC SetEvent(HANDLE hEvent) {
return FALSE; return FALSE;
} }
ev->set(); ev->set();
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -246,7 +243,6 @@ BOOL WIN_FUNC ResetEvent(HANDLE hEvent) {
return FALSE; return FALSE;
} }
ev->reset(); ev->reset();
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -380,7 +376,6 @@ BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,
} }
std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection)); std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection));
lpCriticalSection->SpinCount = dwSpinCount; lpCriticalSection->SpinCount = dwSpinCount;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -393,7 +388,6 @@ BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCritica
} }
std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection)); std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection));
lpCriticalSection->SpinCount = dwSpinCount; lpCriticalSection->SpinCount = dwSpinCount;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -432,7 +426,6 @@ BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBO
if (lpContext) { if (lpContext) {
*lpContext = nullptr; *lpContext = nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -447,7 +440,6 @@ BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpC
wibo::lastError = ERROR_INVALID_PARAMETER; wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
(void)lpContext; (void)lpContext;
return TRUE; return TRUE;
} }

1
dll/kernel32/sysinfoapi.cpp
View File

@ -202,7 +202,6 @@ BOOL WIN_FUNC GetVersionExA(LPOSVERSIONINFOA lpVersionInformation) {
lpVersionInformation->dwMinorVersion = kMinorVersion; lpVersionInformation->dwMinorVersion = kMinorVersion;
lpVersionInformation->dwBuildNumber = kBuildNumber; lpVersionInformation->dwBuildNumber = kBuildNumber;
lpVersionInformation->dwPlatformId = 2; lpVersionInformation->dwPlatformId = 2;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

7
dll/kernel32/timezoneapi.cpp
View File

@ -33,7 +33,6 @@ BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lp
return FALSE; return FALSE;
} }
*lpFileTime = result; *lpFileTime = result;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -63,7 +62,6 @@ BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSy
lpSystemTime->wMinute = static_cast<WORD>((secondsOfDay % 3600U) / 60U); lpSystemTime->wMinute = static_cast<WORD>((secondsOfDay % 3600U) / 60U);
lpSystemTime->wSecond = static_cast<WORD>(secondsOfDay % 60U); lpSystemTime->wSecond = static_cast<WORD>(secondsOfDay % 60U);
lpSystemTime->wMilliseconds = static_cast<WORD>(hundredNs / HUNDRED_NS_PER_MILLISECOND); lpSystemTime->wMilliseconds = static_cast<WORD>(hundredNs / HUNDRED_NS_PER_MILLISECOND);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -113,7 +111,6 @@ BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpL
return FALSE; return FALSE;
} }
*lpLocalFileTime = result; *lpLocalFileTime = result;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -156,7 +153,6 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM
return FALSE; return FALSE;
} }
*lpFileTime = result; *lpFileTime = result;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -192,7 +188,6 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF
} }
uint64_t ticks = (static_cast<uint64_t>(localSeconds) + UNIX_TIME_ZERO / HUNDRED_NS_PER_SECOND) * 10000000ULL; uint64_t ticks = (static_cast<uint64_t>(localSeconds) + UNIX_TIME_ZERO / HUNDRED_NS_PER_SECOND) * 10000000ULL;
*lpFileTime = fileTimeFromDuration(ticks); *lpFileTime = fileTimeFromDuration(ticks);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -222,7 +217,6 @@ BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate
*lpFatDate = static_cast<WORD>(((year - 1980) << 9) | ((tmValue.tm_mon + 1) << 5) | tmValue.tm_mday); *lpFatDate = static_cast<WORD>(((year - 1980) << 9) | ((tmValue.tm_mon + 1) << 5) | tmValue.tm_mday);
*lpFatTime = static_cast<WORD>(((tmValue.tm_hour & 0x1F) << 11) | ((tmValue.tm_min & 0x3F) << 5) | *lpFatTime = static_cast<WORD>(((tmValue.tm_hour & 0x1F) << 11) | ((tmValue.tm_min & 0x3F) << 5) |
((tmValue.tm_sec / 2) & 0x1F)); ((tmValue.tm_sec / 2) & 0x1F));
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -279,7 +273,6 @@ DWORD WIN_FUNC GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformat
} else { } else {
result = TIME_ZONE_ID_STANDARD; result = TIME_ZONE_ID_STANDARD;
} }
wibo::lastError = ERROR_SUCCESS;
return result; return result;
} }

42
dll/kernel32/winbase.cpp
View File

@ -1,5 +1,6 @@
#include "winbase.h" #include "winbase.h"
#include "common.h"
#include "context.h" #include "context.h"
#include "errors.h" #include "errors.h"
#include "files.h" #include "files.h"
@ -86,7 +87,6 @@ bool tryHandleIntegerAtomPointer(const void *ptr, ATOM &atomOut) {
atomOut = 0; atomOut = 0;
return true; return true;
} }
wibo::lastError = ERROR_SUCCESS;
atomOut = maybeAtom; atomOut = maybeAtom;
return true; return true;
} }
@ -99,7 +99,6 @@ ATOM findAtomByNormalizedKey(const std::string &normalizedKey) {
wibo::lastError = ERROR_FILE_NOT_FOUND; wibo::lastError = ERROR_FILE_NOT_FOUND;
return 0; return 0;
} }
wibo::lastError = ERROR_SUCCESS;
return it->second; return it->second;
} }
@ -118,7 +117,6 @@ ATOM tryParseIntegerAtomString(const std::string &value, bool &handled) {
wibo::lastError = ERROR_INVALID_PARAMETER; wibo::lastError = ERROR_INVALID_PARAMETER;
return 0; return 0;
} }
wibo::lastError = ERROR_SUCCESS;
return static_cast<ATOM>(parsed); return static_cast<ATOM>(parsed);
} }
@ -151,7 +149,6 @@ ATOM addAtomByString(const std::string &value) {
if (dataIt != table.atomToData.end() && dataIt->second.refCount < std::numeric_limits<uint16_t>::max()) { if (dataIt != table.atomToData.end() && dataIt->second.refCount < std::numeric_limits<uint16_t>::max()) {
dataIt->second.refCount++; dataIt->second.refCount++;
} }
wibo::lastError = ERROR_SUCCESS;
return existing->second; return existing->second;
} }
ATOM newAtom = allocateStringAtomLocked(table); ATOM newAtom = allocateStringAtomLocked(table);
@ -164,7 +161,6 @@ ATOM addAtomByString(const std::string &value) {
data.original = value; data.original = value;
table.stringToAtom.emplace(std::move(normalized), newAtom); table.stringToAtom.emplace(std::move(normalized), newAtom);
table.atomToData.emplace(newAtom, std::move(data)); table.atomToData.emplace(newAtom, std::move(data));
wibo::lastError = ERROR_SUCCESS;
return newAtom; return newAtom;
} }
@ -196,8 +192,7 @@ bool tryGetCurrentDirectoryPath(std::string &outPath) {
std::error_code ec; std::error_code ec;
std::filesystem::path cwd = std::filesystem::current_path(ec); std::filesystem::path cwd = std::filesystem::current_path(ec);
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
kernel32::setLastErrorFromErrno();
return false; return false;
} }
outPath = files::pathToWindows(cwd); outPath = files::pathToWindows(cwd);
@ -227,7 +222,6 @@ bool computeLongWindowsPath(const std::string &inputPath, std::string &longPath)
if (hasTrailingSlash && !longPath.empty() && longPath.back() != '\\') { if (hasTrailingSlash && !longPath.empty() && longPath.back() != '\\') {
longPath.push_back('\\'); longPath.push_back('\\');
} }
wibo::lastError = ERROR_SUCCESS;
return true; return true;
} }
@ -271,21 +265,18 @@ bool resolveDiskFreeSpaceStat(const char *rootPathName, struct statvfs &outBuf,
} }
if (statvfs(query.c_str(), &outBuf) == 0) { if (statvfs(query.c_str(), &outBuf) == 0) {
resolvedPath = query; resolvedPath = query;
wibo::lastError = ERROR_SUCCESS;
return true; return true;
} }
int savedErrno = errno; int savedErrno = errno;
if (savedErrno != ENOENT && savedErrno != ENOTDIR) { if (savedErrno != ENOENT && savedErrno != ENOTDIR) {
errno = savedErrno; wibo::lastError = wibo::winErrorFromErrno(savedErrno);
kernel32::setLastErrorFromErrno();
return false; return false;
} }
std::filesystem::path parent = queryPath.parent_path(); std::filesystem::path parent = queryPath.parent_path();
if (parent == queryPath) { if (parent == queryPath) {
errno = savedErrno; wibo::lastError = wibo::winErrorFromErrno(savedErrno);
kernel32::setLastErrorFromErrno();
return false; return false;
} }
if (parent.empty()) { if (parent.empty()) {
@ -465,7 +456,6 @@ UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) {
} }
std::memcpy(lpBuffer, value.c_str(), value.size()); std::memcpy(lpBuffer, value.c_str(), value.size());
lpBuffer[value.size()] = '\0'; lpBuffer[value.size()] = '\0';
wibo::lastError = ERROR_SUCCESS;
UINT written = static_cast<UINT>(value.size()); UINT written = static_cast<UINT>(value.size());
DEBUG_LOG("GetAtomNameA -> %u (lastError=%u)\n", written, wibo::lastError); DEBUG_LOG("GetAtomNameA -> %u (lastError=%u)\n", written, wibo::lastError);
return written; return written;
@ -502,7 +492,6 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
if (needed > 0) { if (needed > 0) {
lpBuffer[needed - 1] = 0; lpBuffer[needed - 1] = 0;
} }
wibo::lastError = ERROR_SUCCESS;
UINT written = static_cast<UINT>(needed ? needed - 1 : 0); UINT written = static_cast<UINT>(needed ? needed - 1 : 0);
DEBUG_LOG("GetAtomNameW -> %u (lastError=%u)\n", written, wibo::lastError); DEBUG_LOG("GetAtomNameW -> %u (lastError=%u)\n", written, wibo::lastError);
return written; return written;
@ -546,7 +535,6 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId
return 0; return 0;
} }
lpBuffer[length] = '\0'; lpBuffer[length] = '\0';
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(length); return static_cast<DWORD>(length);
} else if (dwFlags & 0x00000200) { } else if (dwFlags & 0x00000200) {
// FORMAT_MESSAGE_IGNORE_INSERTS // FORMAT_MESSAGE_IGNORE_INSERTS
@ -578,7 +566,6 @@ BOOL WIN_FUNC SetDllDirectoryA(LPCSTR lpPathName) {
DEBUG_LOG("SetDllDirectoryA(%s)\n", lpPathName); DEBUG_LOG("SetDllDirectoryA(%s)\n", lpPathName);
if (!lpPathName || lpPathName[0] == '\0') { if (!lpPathName || lpPathName[0] == '\0') {
wibo::clearDllDirectoryOverride(); wibo::clearDllDirectoryOverride();
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -589,7 +576,6 @@ BOOL WIN_FUNC SetDllDirectoryA(LPCSTR lpPathName) {
} }
wibo::setDllDirectoryOverride(std::filesystem::absolute(hostPath)); wibo::setDllDirectoryOverride(std::filesystem::absolute(hostPath));
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -671,7 +657,6 @@ BOOL WIN_FUNC FindActCtxSectionStringW(DWORD dwFlags, const GUID *lpExtensionGui
ReturnedData->ulAssemblyRosterIndex = 1; ReturnedData->ulAssemblyRosterIndex = 1;
ReturnedData->AssemblyMetadata = {}; ReturnedData->AssemblyMetadata = {};
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -734,7 +719,6 @@ BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) {
std::strcpy(lpBuffer, kComputerNameAnsi); std::strcpy(lpBuffer, kComputerNameAnsi);
*nSize = kComputerNameLength; *nSize = kComputerNameLength;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -757,7 +741,6 @@ BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) {
wstrncpy(lpBuffer, kComputerNameWide, static_cast<size_t>(kComputerNameRequiredSize)); wstrncpy(lpBuffer, kComputerNameWide, static_cast<size_t>(kComputerNameRequiredSize));
*nSize = kComputerNameLength; *nSize = kComputerNameLength;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -813,7 +796,6 @@ HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) {
// Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalAlloc. // Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalAlloc.
tryMarkExecutable(result); tryMarkExecutable(result);
DEBUG_LOG(" -> %p\n", result); DEBUG_LOG(" -> %p\n", result);
wibo::lastError = ERROR_SUCCESS;
return result; return result;
} }
@ -822,7 +804,6 @@ HLOCAL WIN_FUNC LocalFree(HLOCAL hMem) {
VERBOSE_LOG("LocalFree(%p)\n", hMem); VERBOSE_LOG("LocalFree(%p)\n", hMem);
// Windows returns NULL on success. // Windows returns NULL on success.
std::free(hMem); std::free(hMem);
wibo::lastError = ERROR_SUCCESS;
return nullptr; return nullptr;
} }
@ -841,7 +822,6 @@ HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) {
// Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalReAlloc. // Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalReAlloc.
tryMarkExecutable(result); tryMarkExecutable(result);
DEBUG_LOG(" -> %p\n", result); DEBUG_LOG(" -> %p\n", result);
wibo::lastError = ERROR_SUCCESS;
return result; return result;
} }
@ -854,7 +834,6 @@ HLOCAL WIN_FUNC LocalHandle(LPCVOID pMem) {
LPVOID WIN_FUNC LocalLock(HLOCAL hMem) { LPVOID WIN_FUNC LocalLock(HLOCAL hMem) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
VERBOSE_LOG("LocalLock(%p)\n", hMem); VERBOSE_LOG("LocalLock(%p)\n", hMem);
wibo::lastError = ERROR_SUCCESS;
return hMem; return hMem;
} }
@ -862,7 +841,6 @@ BOOL WIN_FUNC LocalUnlock(HLOCAL hMem) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
VERBOSE_LOG("LocalUnlock(%p)\n", hMem); VERBOSE_LOG("LocalUnlock(%p)\n", hMem);
(void)hMem; (void)hMem;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -989,7 +967,6 @@ DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
return required; return required;
} }
std::memcpy(lpBuffer, path.c_str(), required); std::memcpy(lpBuffer, path.c_str(), required);
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -1015,7 +992,6 @@ DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
return required; return required;
} }
std::copy(widePath.begin(), widePath.end(), lpBuffer); std::copy(widePath.begin(), widePath.end(), lpBuffer);
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -1030,11 +1006,9 @@ int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) {
std::error_code ec; std::error_code ec;
std::filesystem::current_path(hostPath, ec); std::filesystem::current_path(hostPath, ec);
if (ec) { if (ec) {
errno = ec.value(); wibo::lastError = wibo::winErrorFromErrno(ec.value());
kernel32::setLastErrorFromErrno();
return 0; return 0;
} }
wibo::lastError = ERROR_SUCCESS;
return 1; return 1;
} }
@ -1076,7 +1050,6 @@ DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD
return required; return required;
} }
std::memcpy(lpszLongPath, longPath.c_str(), required); std::memcpy(lpszLongPath, longPath.c_str(), required);
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -1106,7 +1079,6 @@ DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWOR
return required; return required;
} }
std::copy(wideLong.begin(), wideLong.end(), lpszLongPath); std::copy(wideLong.begin(), wideLong.end(), lpszLongPath);
wibo::lastError = ERROR_SUCCESS;
return required - 1; return required - 1;
} }
@ -1158,8 +1130,6 @@ BOOL WIN_FUNC GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerClust
lpSectorsPerCluster ? *lpSectorsPerCluster : 0, lpBytesPerSector ? *lpBytesPerSector : 0, lpSectorsPerCluster ? *lpSectorsPerCluster : 0, lpBytesPerSector ? *lpBytesPerSector : 0,
lpNumberOfFreeClusters ? *lpNumberOfFreeClusters : 0, lpNumberOfFreeClusters ? *lpNumberOfFreeClusters : 0,
lpTotalNumberOfClusters ? *lpTotalNumberOfClusters : 0); lpTotalNumberOfClusters ? *lpTotalNumberOfClusters : 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -1203,8 +1173,6 @@ BOOL WIN_FUNC GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, uint64_t *lpFreeBytesA
DEBUG_LOG("\t-> host %s, free %llu, total %llu, total free %llu\n", resolvedPath.c_str(), DEBUG_LOG("\t-> host %s, free %llu, total %llu, total free %llu\n", resolvedPath.c_str(),
static_cast<unsigned long long>(freeToCaller), static_cast<unsigned long long>(totalBytes), static_cast<unsigned long long>(freeToCaller), static_cast<unsigned long long>(totalBytes),
static_cast<unsigned long long>(totalFree)); static_cast<unsigned long long>(totalFree));
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

9
dll/kernel32/wincon.cpp
View File

@ -14,7 +14,6 @@ BOOL WIN_FUNC GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode) {
if (lpMode) { if (lpMode) {
*lpMode = 0; *lpMode = 0;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -23,21 +22,18 @@ BOOL WIN_FUNC SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode) {
DEBUG_LOG("STUB: SetConsoleMode(%p, 0x%x)\n", hConsoleHandle, dwMode); DEBUG_LOG("STUB: SetConsoleMode(%p, 0x%x)\n", hConsoleHandle, dwMode);
(void)hConsoleHandle; (void)hConsoleHandle;
(void)dwMode; (void)dwMode;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
UINT WIN_FUNC GetConsoleCP() { UINT WIN_FUNC GetConsoleCP() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetConsoleCP() -> 65001\n"); DEBUG_LOG("STUB: GetConsoleCP() -> 65001\n");
wibo::lastError = ERROR_SUCCESS;
return 65001; // UTF-8 return 65001; // UTF-8
} }
UINT WIN_FUNC GetConsoleOutputCP() { UINT WIN_FUNC GetConsoleOutputCP() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetConsoleOutputCP() -> 65001\n"); DEBUG_LOG("STUB: GetConsoleOutputCP() -> 65001\n");
wibo::lastError = ERROR_SUCCESS;
return 65001; // UTF-8 return 65001; // UTF-8
} }
@ -46,7 +42,6 @@ BOOL WIN_FUNC SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add) {
DEBUG_LOG("STUB: SetConsoleCtrlHandler(%p, %u)\n", reinterpret_cast<const void *>(HandlerRoutine), Add); DEBUG_LOG("STUB: SetConsoleCtrlHandler(%p, %u)\n", reinterpret_cast<const void *>(HandlerRoutine), Add);
(void)HandlerRoutine; (void)HandlerRoutine;
(void)Add; (void)Add;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -63,7 +58,6 @@ BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_B
lpConsoleScreenBufferInfo->wAttributes = 0; lpConsoleScreenBufferInfo->wAttributes = 0;
lpConsoleScreenBufferInfo->srWindow = {0, 0, 79, 24}; lpConsoleScreenBufferInfo->srWindow = {0, 0, 79, 24};
lpConsoleScreenBufferInfo->dwMaximumWindowSize = {80, 25}; lpConsoleScreenBufferInfo->dwMaximumWindowSize = {80, 25};
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -88,7 +82,6 @@ BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumb
if (lpNumberOfCharsWritten) { if (lpNumberOfCharsWritten) {
*lpNumberOfCharsWritten = nNumberOfCharsToWrite; *lpNumberOfCharsWritten = nNumberOfCharsToWrite;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -126,7 +119,6 @@ BOOL WIN_FUNC PeekConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DW
if (lpNumberOfEventsRead) { if (lpNumberOfEventsRead) {
*lpNumberOfEventsRead = 0; *lpNumberOfEventsRead = 0;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -140,7 +132,6 @@ BOOL WIN_FUNC ReadConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DW
if (lpNumberOfEventsRead) { if (lpNumberOfEventsRead) {
*lpNumberOfEventsRead = 0; *lpNumberOfEventsRead = 0;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

22
dll/kernel32/winnls.cpp
View File

@ -85,7 +85,6 @@ namespace kernel32 {
UINT WIN_FUNC GetACP() { UINT WIN_FUNC GetACP() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetACP() -> %u\n", 28591); DEBUG_LOG("GetACP() -> %u\n", 28591);
wibo::lastError = ERROR_SUCCESS;
return 28591; // Latin1 (ISO/IEC 8859-1) return 28591; // Latin1 (ISO/IEC 8859-1)
} }
@ -115,8 +114,6 @@ BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) {
std::fill(lpCPInfo->DefaultChar, lpCPInfo->DefaultChar + MAX_DEFAULTCHAR, 0); std::fill(lpCPInfo->DefaultChar, lpCPInfo->DefaultChar + MAX_DEFAULTCHAR, 0);
lpCPInfo->DefaultChar[0] = '?'; lpCPInfo->DefaultChar[0] = '?';
std::fill(lpCPInfo->LeadByte, lpCPInfo->LeadByte + MAX_LEADBYTES, 0); std::fill(lpCPInfo->LeadByte, lpCPInfo->LeadByte + MAX_LEADBYTES, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -140,7 +137,6 @@ int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int
std::string str1(lpString1, lpString1 + cchCount1); std::string str1(lpString1, lpString1 + cchCount1);
std::string str2(lpString2, lpString2 + cchCount2); std::string str2(lpString2, lpString2 + cchCount2);
wibo::lastError = ERROR_SUCCESS;
return compareStrings(str1, str2, dwCmpFlags); return compareStrings(str1, str2, dwCmpFlags);
} }
@ -157,7 +153,6 @@ int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int
std::string str1 = wideStringToString(lpString1, cchCount1); std::string str1 = wideStringToString(lpString1, cchCount1);
std::string str2 = wideStringToString(lpString2, cchCount2); std::string str2 = wideStringToString(lpString2, cchCount2);
wibo::lastError = ERROR_SUCCESS;
return compareStrings(str1, str2, dwCmpFlags); return compareStrings(str1, str2, dwCmpFlags);
} }
@ -165,7 +160,6 @@ BOOL WIN_FUNC IsValidCodePage(UINT CodePage) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("IsValidCodePage(%u)\n", CodePage); DEBUG_LOG("IsValidCodePage(%u)\n", CodePage);
(void)CodePage; (void)CodePage;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -177,7 +171,6 @@ BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) {
wibo::lastError = ERROR_INVALID_PARAMETER; wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE; return FALSE;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -190,7 +183,6 @@ int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchD
size_t required = value.size() + 1; size_t required = value.size() + 1;
if (cchData == 0) { if (cchData == 0) {
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(required); return static_cast<int>(required);
} }
if (!lpLCData || cchData < 0) { if (!lpLCData || cchData < 0) {
@ -203,7 +195,6 @@ int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchD
} }
std::memcpy(lpLCData, value.c_str(), required); std::memcpy(lpLCData, value.c_str(), required);
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(required); return static_cast<int>(required);
} }
@ -217,7 +208,6 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch
size_t required = wide.size(); size_t required = wide.size();
if (cchData == 0) { if (cchData == 0) {
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(required); return static_cast<int>(required);
} }
if (!lpLCData || cchData < 0) { if (!lpLCData || cchData < 0) {
@ -230,7 +220,6 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch
} }
std::memcpy(lpLCData, wide.data(), required * sizeof(uint16_t)); std::memcpy(lpLCData, wide.data(), required * sizeof(uint16_t));
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(required); return static_cast<int>(required);
} }
@ -244,14 +233,12 @@ BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlag
} }
char localeId[] = "00000409"; // en-US char localeId[] = "00000409"; // en-US
BOOL callbackResult = lpLocaleEnumProc(localeId); BOOL callbackResult = lpLocaleEnumProc(localeId);
wibo::lastError = ERROR_SUCCESS;
return callbackResult; return callbackResult;
} }
LCID WIN_FUNC GetUserDefaultLCID() { LCID WIN_FUNC GetUserDefaultLCID() {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetUserDefaultLCID()\n"); DEBUG_LOG("GetUserDefaultLCID()\n");
wibo::lastError = ERROR_SUCCESS;
return 0x0409; // en-US return 0x0409; // en-US
} }
@ -259,7 +246,6 @@ BOOL WIN_FUNC IsDBCSLeadByte(BYTE TestChar) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("IsDBCSLeadByte(%u)\n", TestChar); DEBUG_LOG("IsDBCSLeadByte(%u)\n", TestChar);
(void)TestChar; (void)TestChar;
wibo::lastError = ERROR_SUCCESS;
return FALSE; return FALSE;
} }
@ -276,22 +262,20 @@ BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) {
return FALSE; return FALSE;
}; };
wibo::lastError = ERROR_SUCCESS;
switch (CodePage) { switch (CodePage) {
case 932: // Shift-JIS case 932: // Shift-JIS
wibo::lastError = ERROR_SUCCESS;
return inRanges({{0x81, 0x9F}, {0xE0, 0xFC}}); return inRanges({{0x81, 0x9F}, {0xE0, 0xFC}});
case 936: // GBK case 936: // GBK
case 949: // Korean case 949: // Korean
case 950: // Big5 case 950: // Big5
case 1361: // Johab case 1361: // Johab
wibo::lastError = ERROR_SUCCESS;
return inRanges({{0x81, 0xFE}}); return inRanges({{0x81, 0xFE}});
case 0: // CP_ACP case 0: // CP_ACP
case 1: // CP_OEMCP case 1: // CP_OEMCP
case 2: // CP_MACCP case 2: // CP_MACCP
case 3: // CP_THREAD_ACP case 3: // CP_THREAD_ACP
default: default:
wibo::lastError = ERROR_SUCCESS;
return FALSE; return FALSE;
} }
} }
@ -313,7 +297,6 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc
} }
if (!lpDestStr || cchDest == 0) { if (!lpDestStr || cchDest == 0) {
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(srcLen); return static_cast<int>(srcLen);
} }
if (cchDest < static_cast<int>(srcLen)) { if (cchDest < static_cast<int>(srcLen)) {
@ -341,7 +324,6 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc
} }
std::memcpy(lpDestStr, buffer.data(), srcLen * sizeof(uint16_t)); std::memcpy(lpDestStr, buffer.data(), srcLen * sizeof(uint16_t));
wibo::lastError = ERROR_SUCCESS;
return static_cast<int>(srcLen); return static_cast<int>(srcLen);
} }
@ -362,6 +344,7 @@ int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cch
int wideResult = int wideResult =
LCMapStringW(Locale, dwMapFlags, wideSrc.data(), length, wideDest.empty() ? nullptr : wideDest.data(), cchDest); LCMapStringW(Locale, dwMapFlags, wideSrc.data(), length, wideDest.empty() ? nullptr : wideDest.data(), cchDest);
if (wideResult == 0) { if (wideResult == 0) {
wibo::lastError = ERROR_SUCCESS;
return 0; return 0;
} }
@ -376,7 +359,6 @@ int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cch
return 0; return 0;
} }
std::memcpy(lpDestStr, mapped.c_str(), bytesToCopy); std::memcpy(lpDestStr, mapped.c_str(), bytesToCopy);
wibo::lastError = ERROR_SUCCESS;
return wideResult; return wideResult;
} }

3
dll/kernel32/wow64apiset.cpp
View File

@ -14,7 +14,6 @@ BOOL WIN_FUNC Wow64DisableWow64FsRedirection(PVOID *OldValue) {
if (OldValue) { if (OldValue) {
*OldValue = nullptr; *OldValue = nullptr;
} }
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -22,7 +21,6 @@ BOOL WIN_FUNC Wow64RevertWow64FsRedirection(PVOID OldValue) {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: Wow64RevertWow64FsRedirection(%p)\n", OldValue); DEBUG_LOG("STUB: Wow64RevertWow64FsRedirection(%p)\n", OldValue);
(void)OldValue; (void)OldValue;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
@ -47,7 +45,6 @@ BOOL WIN_FUNC IsWow64Process(HANDLE hProcess, PBOOL Wow64Process) {
} }
*Wow64Process = FALSE; *Wow64Process = FALSE;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }

5
dll/user32.cpp
View File

@ -129,14 +129,12 @@ namespace user32 {
HOST_CONTEXT_GUARD(); HOST_CONTEXT_GUARD();
DEBUG_LOG("GetKeyboardLayout(%u)\n", idThread); DEBUG_LOG("GetKeyboardLayout(%u)\n", idThread);
(void)idThread; (void)idThread;
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HKL>(kDefaultKeyboardLayout); return reinterpret_cast<HKL>(kDefaultKeyboardLayout);
} }
HWINSTA WIN_FUNC GetProcessWindowStation() { HWINSTA WIN_FUNC GetProcessWindowStation() {
DEBUG_LOG("GetProcessWindowStation()\n"); DEBUG_LOG("GetProcessWindowStation()\n");
static int kWindowStationStub; static int kWindowStationStub;
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HWINSTA>(&kWindowStationStub); return reinterpret_cast<HWINSTA>(&kWindowStationStub);
} }
@ -164,14 +162,11 @@ namespace user32 {
flags->fInherit = FALSE; flags->fInherit = FALSE;
flags->fReserved = FALSE; flags->fReserved = FALSE;
flags->dwFlags = WSF_VISIBLE; flags->dwFlags = WSF_VISIBLE;
wibo::lastError = ERROR_SUCCESS;
return TRUE; return TRUE;
} }
HWND WIN_FUNC GetActiveWindow() { HWND WIN_FUNC GetActiveWindow() {
DEBUG_LOG("GetActiveWindow()\n"); DEBUG_LOG("GetActiveWindow()\n");
wibo::lastError = ERROR_SUCCESS;
return nullptr; return nullptr;
} }
} }

2
dll/version.cpp
View File

@ -192,7 +192,6 @@ static bool loadVersionResource(const char *fileName, std::vector<uint8_t> &buff
const uint8_t *start = static_cast<const uint8_t *>(loc.data); const uint8_t *start = static_cast<const uint8_t *>(loc.data);
buffer.assign(start, start + loc.size); buffer.assign(start, start + loc.size);
wibo::lastError = ERROR_SUCCESS;
return true; return true;
} }
@ -235,7 +234,6 @@ unsigned int WIN_FUNC GetFileVersionInfoA(const char *lptstrFilename, unsigned i
if (buffer.size() < dwLen) { if (buffer.size() < dwLen) {
std::memset(static_cast<uint8_t *>(lpData) + buffer.size(), 0, dwLen - buffer.size()); std::memset(static_cast<uint8_t *>(lpData) + buffer.size(), 0, dwLen - buffer.size());
} }
wibo::lastError = ERROR_SUCCESS;
return 1; return 1;
} }

3
src/main.cpp
View File

@ -557,6 +557,9 @@ int main(int argc, char **argv) {
abort(); abort();
} }
// Reset last error
wibo::lastError = 0;
// Invoke the damn thing // Invoke the damn thing
{ {
GUEST_CONTEXT_GUARD(&tib); GUEST_CONTEXT_GUARD(&tib);

10
src/modules.cpp
View File

@ -425,6 +425,9 @@ BOOL callDllMain(wibo::ModuleInfo &info, DWORD reason, LPVOID reserved) {
return TRUE; return TRUE;
} }
// Reset last error
wibo::lastError = ERROR_SUCCESS;
using DllMainFunc = BOOL(WIN_FUNC *)(HMODULE, DWORD, LPVOID); using DllMainFunc = BOOL(WIN_FUNC *)(HMODULE, DWORD, LPVOID);
auto dllMain = reinterpret_cast<DllMainFunc>(entry); auto dllMain = reinterpret_cast<DllMainFunc>(entry);
@ -789,6 +792,7 @@ void notifyDllThreadAttach() {
for (wibo::ModuleInfo *info : targets) { for (wibo::ModuleInfo *info : targets) {
callDllMain(*info, DLL_THREAD_ATTACH, nullptr); callDllMain(*info, DLL_THREAD_ATTACH, nullptr);
} }
wibo::lastError = ERROR_SUCCESS;
} }
void notifyDllThreadDetach() { void notifyDllThreadDetach() {
@ -804,6 +808,7 @@ void notifyDllThreadDetach() {
for (auto it = targets.rbegin(); it != targets.rend(); ++it) { for (auto it = targets.rbegin(); it != targets.rend(); ++it) {
callDllMain(**it, DLL_THREAD_DETACH, nullptr); callDllMain(**it, DLL_THREAD_DETACH, nullptr);
} }
wibo::lastError = ERROR_SUCCESS;
} }
BOOL disableThreadNotifications(ModuleInfo *info) { BOOL disableThreadNotifications(ModuleInfo *info) {
@ -947,28 +952,24 @@ ModuleInfo *loadModule(const char *dllName) {
existing->refCount++; existing->refCount++;
} }
DEBUG_LOG(" returning existing external module %s\n", existing->originalName.c_str()); DEBUG_LOG(" returning existing external module %s\n", existing->originalName.c_str());
lastError = ERROR_SUCCESS;
return existing; return existing;
} }
bool pinned = reg->pinnedModules.count(existing) != 0; bool pinned = reg->pinnedModules.count(existing) != 0;
if (!pinned) { if (!pinned) {
if (ModuleInfo *external = resolveAndLoadExternal()) { if (ModuleInfo *external = resolveAndLoadExternal()) {
DEBUG_LOG(" replaced builtin module %s with external copy\n", requested.c_str()); DEBUG_LOG(" replaced builtin module %s with external copy\n", requested.c_str());
lastError = ERROR_SUCCESS;
return external; return external;
} else if (diskError != ERROR_MOD_NOT_FOUND) { } else if (diskError != ERROR_MOD_NOT_FOUND) {
lastError = diskError; lastError = diskError;
return nullptr; return nullptr;
} }
} }
lastError = ERROR_SUCCESS;
DEBUG_LOG(" returning builtin module %s\n", existing->originalName.c_str()); DEBUG_LOG(" returning builtin module %s\n", existing->originalName.c_str());
return existing; return existing;
} }
if (ModuleInfo *external = resolveAndLoadExternal()) { if (ModuleInfo *external = resolveAndLoadExternal()) {
DEBUG_LOG(" loaded external module %s\n", requested.c_str()); DEBUG_LOG(" loaded external module %s\n", requested.c_str());
lastError = ERROR_SUCCESS;
return external; return external;
} else if (diskError != ERROR_MOD_NOT_FOUND) { } else if (diskError != ERROR_MOD_NOT_FOUND) {
lastError = diskError; lastError = diskError;
@ -989,7 +990,6 @@ ModuleInfo *loadModule(const char *dllName) {
} }
if (builtin && builtin->moduleStub != nullptr) { if (builtin && builtin->moduleStub != nullptr) {
DEBUG_LOG(" falling back to builtin module %s\n", builtin->originalName.c_str()); DEBUG_LOG(" falling back to builtin module %s\n", builtin->originalName.c_str());
lastError = (diskError != ERROR_SUCCESS) ? diskError : ERROR_SUCCESS;
return builtin; return builtin;
} }

43
test/test_actctx.c
View File

@ -22,13 +22,10 @@ static BOOL isRunningUnderWine(void) {
} }
static void check_success_w(void) { static void check_success_w(void) {
ACTCTX_SECTION_KEYED_DATA data = { 0 }; ACTCTX_SECTION_KEYED_DATA data = {0};
data.cbSize = sizeof(data); data.cbSize = sizeof(data);
SetLastError(0); SetLastError(0);
BOOL ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, TEST_CHECK(FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"msvcr80.dll", &data));
L"msvcr80.dll", &data);
TEST_CHECK(ok);
TEST_CHECK_EQ(ERROR_SUCCESS, GetLastError());
TEST_CHECK_EQ(1u, data.ulDataFormatVersion); TEST_CHECK_EQ(1u, data.ulDataFormatVersion);
TEST_CHECK((data.ulFlags & ACTCTX_SECTION_KEYED_DATA_FLAG_FOUND_IN_ACTCTX) != 0); TEST_CHECK((data.ulFlags & ACTCTX_SECTION_KEYED_DATA_FLAG_FOUND_IN_ACTCTX) != 0);
TEST_CHECK(data.lpData != NULL); TEST_CHECK(data.lpData != NULL);
@ -38,14 +35,11 @@ static void check_success_w(void) {
} }
static void check_success_a(void) { static void check_success_a(void) {
ACTCTX_SECTION_KEYED_DATA data = { 0 }; ACTCTX_SECTION_KEYED_DATA data = {0};
data.cbSize = sizeof(data); data.cbSize = sizeof(data);
SetLastError(0); SetLastError(0);
BOOL ok = FindActCtxSectionStringA(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL, TEST_CHECK(FindActCtxSectionStringA(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "msvcp80.dll", &data));
"msvcp80.dll", &data);
TEST_CHECK(ok);
TEST_CHECK_EQ(ERROR_SUCCESS, GetLastError());
TEST_CHECK((data.ulFlags & ACTCTX_SECTION_KEYED_DATA_FLAG_FOUND_IN_ACTCTX) != 0); TEST_CHECK((data.ulFlags & ACTCTX_SECTION_KEYED_DATA_FLAG_FOUND_IN_ACTCTX) != 0);
TEST_CHECK(data.lpData != NULL); TEST_CHECK(data.lpData != NULL);
TEST_CHECK(data.hActCtx != NULL); TEST_CHECK(data.hActCtx != NULL);
@ -53,46 +47,43 @@ static void check_success_a(void) {
} }
static void check_invalid_parameters(void) { static void check_invalid_parameters(void) {
ACTCTX_SECTION_KEYED_DATA data = { 0 }; ACTCTX_SECTION_KEYED_DATA data = {0};
data.cbSize = sizeof(data); data.cbSize = sizeof(data);
GUID fakeGuid = {0}; GUID fakeGuid = {0};
SetLastError(0); SetLastError(0);
BOOL ok = FindActCtxSectionStringW(0, &fakeGuid, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, BOOL ok = FindActCtxSectionStringW(0, &fakeGuid, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"msvcr80.dll", &data);
L"msvcr80.dll", &data);
TEST_CHECK(!ok); TEST_CHECK(!ok);
TEST_CHECK_EQ(ERROR_INVALID_PARAMETER, GetLastError()); TEST_CHECK_EQ(ERROR_INVALID_PARAMETER, GetLastError());
ACTCTX_SECTION_KEYED_DATA sized = { 0 }; ACTCTX_SECTION_KEYED_DATA sized = {0};
sized.cbSize = sizeof(data) - 4; sized.cbSize = sizeof(data) - 4;
SetLastError(0); SetLastError(0);
ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"msvcr80.dll", &sized);
L"msvcr80.dll", &sized);
TEST_CHECK(!ok); TEST_CHECK(!ok);
TEST_CHECK_EQ(ERROR_INSUFFICIENT_BUFFER, GetLastError()); TEST_CHECK_EQ(ERROR_INSUFFICIENT_BUFFER, GetLastError());
ACTCTX_SECTION_KEYED_DATA flags = { 0 }; ACTCTX_SECTION_KEYED_DATA flags = {0};
flags.cbSize = sizeof(flags); flags.cbSize = sizeof(flags);
SetLastError(0); SetLastError(0);
ok = FindActCtxSectionStringW(0x2, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, ok = FindActCtxSectionStringW(0x2, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"msvcr80.dll", &flags);
L"msvcr80.dll", &flags);
TEST_CHECK(!ok); TEST_CHECK(!ok);
TEST_CHECK_EQ(ERROR_INVALID_PARAMETER, GetLastError()); TEST_CHECK_EQ(ERROR_INVALID_PARAMETER, GetLastError());
} }
static void check_missing_entries(void) { static void check_missing_entries(void) {
ACTCTX_SECTION_KEYED_DATA data = { 0 }; ACTCTX_SECTION_KEYED_DATA data = {0};
data.cbSize = sizeof(data); data.cbSize = sizeof(data);
SetLastError(0); SetLastError(0);
BOOL ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, BOOL ok =
L"totally_missing.dll", &data); FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, L"totally_missing.dll", &data);
TEST_CHECK(!ok); TEST_CHECK(!ok);
TEST_CHECK_EQ(ERROR_SXS_KEY_NOT_FOUND, GetLastError()); TEST_CHECK_EQ(ERROR_SXS_KEY_NOT_FOUND, GetLastError());
ACTCTX_SECTION_KEYED_DATA wrongSection = { 0 }; ACTCTX_SECTION_KEYED_DATA wrongSection = {0};
wrongSection.cbSize = sizeof(wrongSection); wrongSection.cbSize = sizeof(wrongSection);
SetLastError(0); SetLastError(0);
ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, ok = FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, L"msvcr80.dll",
L"msvcr80.dll", &wrongSection); &wrongSection);
TEST_CHECK(!ok); TEST_CHECK(!ok);
TEST_CHECK_EQ(ERROR_SXS_KEY_NOT_FOUND, GetLastError()); TEST_CHECK_EQ(ERROR_SXS_KEY_NOT_FOUND, GetLastError());
} }