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

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);
*TokenHandle = wibo::handles().alloc(std::move(token), 0, 0);
wibo::lastError = ERROR_SUCCESS;
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->AceCount = 0;
pAcl->Sbz2 = static_cast<WORD>(nAclLength);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -199,7 +198,6 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa
std::memcpy(&ace->SidStart, sid, sidLen);
pAcl->AceCount = static_cast<WORD>(pAcl->AceCount + 1);
pAcl->AclSize = static_cast<WORD>(used + aceSize);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -223,7 +221,6 @@ BOOL WIN_FUNC FindFirstFreeAce(PACL pAcl, LPVOID *pAce) {
}
*pAce = reinterpret_cast<BYTE *>(pAcl) + used;
pAcl->AclSize = static_cast<WORD>(std::max<size_t>(pAcl->AclSize, used));
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -253,7 +250,6 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
if (lpbDaclDefaulted) {
*lpbDaclDefaulted = FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (pDacl) {
@ -262,7 +258,6 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
if (lpbDaclDefaulted) {
*lpbDaclDefaulted = (pSecurityDescriptor->Control & SE_DACL_DEFAULTED) ? TRUE : FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -278,7 +273,6 @@ PSID_IDENTIFIER_AUTHORITY WIN_FUNC GetSidIdentifierAuthority(PSID pSid) {
wibo::lastError = ERROR_INVALID_SID;
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<PSID_IDENTIFIER_AUTHORITY>(&sid->IdentifierAuthority);
}
@ -294,7 +288,6 @@ PUCHAR WIN_FUNC GetSidSubAuthorityCount(PSID pSid) {
wibo::lastError = ERROR_INVALID_SID;
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
return &sid->SubAuthorityCount;
}
@ -310,7 +303,6 @@ PDWORD WIN_FUNC GetSidSubAuthority(PSID pSid, DWORD nSubAuthority) {
wibo::lastError = ERROR_INVALID_SID;
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
return &sid->SubAuthority[nSubAuthority];
}
@ -318,7 +310,6 @@ BOOL WIN_FUNC ImpersonateLoggedOnUser(HANDLE hToken) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: ImpersonateLoggedOnUser(%p)\n", hToken);
(void)hToken;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -342,7 +333,6 @@ BOOL WIN_FUNC DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, voi
auto newToken =
make_pin<TokenObject>(existing->obj.clone(), dwDesiredAccess == 0 ? existing->desiredAccess : dwDesiredAccess);
*phNewToken = wibo::handles().alloc(std::move(newToken), 0, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -360,7 +350,6 @@ BOOL WIN_FUNC CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pS
return FALSE;
}
std::memcpy(pDestinationSid, pSourceSid, required);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -382,7 +371,6 @@ BOOL WIN_FUNC InitializeSid(PSID sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAutho
if (nSubAuthorityCount > 0) {
std::memset(sidStruct->SubAuthority, 0, sizeof(DWORD) * nSubAuthorityCount);
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -406,7 +394,6 @@ BOOL WIN_FUNC EqualSid(PSID pSid1, PSID pSid2) {
if (equal && sid1->SubAuthorityCount > 0) {
equal = std::memcmp(sid1->SubAuthority, sid2->SubAuthority, sizeof(DWORD) * sid1->SubAuthorityCount) == 0;
}
wibo::lastError = ERROR_SUCCESS;
return equal ? TRUE : FALSE;
}
@ -424,7 +411,6 @@ BOOL WIN_FUNC SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION Securi
wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -442,7 +428,6 @@ BOOL WIN_FUNC InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescrip
pSecurityDescriptor->Group = nullptr;
pSecurityDescriptor->Sacl = nullptr;
pSecurityDescriptor->Dacl = nullptr;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -465,7 +450,6 @@ BOOL WIN_FUNC SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
pSecurityDescriptor->Dacl = nullptr;
}
pSecurityDescriptor->Control = control;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -501,7 +485,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
}
tokenUser->User.SidPtr = sid;
tokenUser->User.Attributes = 0;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
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->authenticationId.LowPart = 1;
stats->modifiedId.LowPart = 1;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenElevation) {
@ -529,7 +511,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
return FALSE;
}
*reinterpret_cast<DWORD *>(TokenInformation) = 0; // not elevated
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (TokenInformationClass == TOKEN_INFORMATION_CLASS::TokenPrimaryGroup) {
@ -546,7 +527,6 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
return FALSE;
}
groupInfo->PrimaryGroup = sid;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
wibo::lastError = ERROR_NOT_SUPPORTED;
@ -564,7 +544,6 @@ BOOL WIN_FUNC AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivilege
(void)BufferLength;
(void)PreviousState;
(void)ReturnLength;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -581,7 +560,6 @@ BOOL WIN_FUNC SetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
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;
*cchName = requiredAccount;
*cchReferencedDomainName = requiredDomain;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -127,7 +126,6 @@ BOOL WIN_FUNC LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lp
std::string normalized = normalizePrivilegeName(lpName);
LUID luid = lookupOrGeneratePrivilegeLuid(normalized);
*lpLuid = luid;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -143,7 +141,6 @@ BOOL WIN_FUNC LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID
std::string normalized = normalizePrivilegeName(ansiName);
LUID luid = lookupOrGeneratePrivilegeLuid(normalized);
*lpLuid = luid;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -163,7 +160,6 @@ BOOL WIN_FUNC GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer) {
}
std::memcpy(lpBuffer, name, needed);
*pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -182,7 +178,6 @@ BOOL WIN_FUNC GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer) {
}
std::memcpy(lpBuffer, kAccountSystem, needed * sizeof(WCHAR));
*pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_SUCCESS;
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);
(void)hProv;
(void)dwFlags;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -227,7 +226,6 @@ BOOL WIN_FUNC CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPC
return FALSE;
}
*phProv = static_cast<HCRYPTPROV>(reinterpret_cast<uintptr_t>(&dummyProvider));
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -246,7 +244,6 @@ BOOL WIN_FUNC CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) {
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -277,7 +274,6 @@ BOOL WIN_FUNC CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DW
hash->data.clear();
hash->digest.clear();
*phHash = hashHandleFromObject(hash);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -299,7 +295,6 @@ BOOL WIN_FUNC CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLe
hash->digestComputed = false;
hash->digest.clear();
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -321,7 +316,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
DWORD required = sizeof(ALG_ID);
if (!pbData) {
*pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (*pdwDataLen < required) {
@ -331,7 +325,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
memcpy(pbData, &hash->algid, required);
*pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
case HP_HASHSIZE: {
@ -349,7 +342,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
if (!pbData) {
*pdwDataLen = sizeof(DWORD);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (*pdwDataLen < sizeof(DWORD)) {
@ -359,7 +351,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
memcpy(pbData, &size, sizeof(DWORD));
*pdwDataLen = sizeof(DWORD);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
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());
if (!pbData) {
*pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
if (*pdwDataLen < required) {
@ -380,7 +370,6 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
memcpy(pbData, hash->digest.data(), required);
*pdwDataLen = required;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
default:
@ -398,7 +387,6 @@ BOOL WIN_FUNC CryptDestroyHash(HCRYPTHASH hHash) {
return FALSE;
}
delete hash;
wibo::lastError = ERROR_SUCCESS;
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) {
*phkResult = hKey;
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS;
}
auto obj = make_pin<RegistryKeyObject>(std::move(targetPath));
auto handle = wibo::handles().alloc(std::move(obj), 0, 0);
*phkResult = reinterpret_cast<HKEY>(handle);
wibo::lastError = 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 (baseHandle->predefined) {
*phkResult = hKey;
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS;
}
}
auto obj = make_pin<RegistryKeyObject>(std::move(targetPath));
auto handle = wibo::handles().alloc(std::move(obj), 0, 0);
*phkResult = reinterpret_cast<HKEY>(handle);
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS;
}
@ -383,7 +379,6 @@ LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("RegCloseKey(%p)\n", hKey);
if (isPredefinedKeyHandle(hKey)) {
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS;
}
auto obj = wibo::handles().getAs<RegistryKeyObject>(hKey);
@ -391,7 +386,6 @@ LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) {
wibo::lastError = ERROR_INVALID_HANDLE;
return ERROR_INVALID_HANDLE;
}
wibo::lastError = ERROR_SUCCESS;
return ERROR_SUCCESS;
}

1
dll/kernel32/debugapi.cpp
View File

@ -9,7 +9,6 @@ namespace kernel32 {
BOOL WIN_FUNC IsDebuggerPresent() {
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: IsDebuggerPresent()\n");
wibo::lastError = ERROR_SUCCESS;
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");
wibo::lastError = 1;
wibo::lastError = FLS_OUT_OF_INDEXES;
return FLS_OUT_OF_INDEXES;
}
@ -38,7 +38,7 @@ BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) {
g_flsValuesUsed[dwFlsIndex] = false;
return TRUE;
} else {
wibo::lastError = 1;
wibo::lastError = ERROR_INVALID_PARAMETER;
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
wibo::lastError = ERROR_SUCCESS;
} else {
wibo::lastError = 1;
wibo::lastError = ERROR_INVALID_PARAMETER;
}
// DEBUG_LOG(" -> %p\n", result);
return result;
@ -65,7 +65,7 @@ BOOL WIN_FUNC FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) {
g_flsValues[dwFlsIndex] = lpFlsData;
return TRUE;
} else {
wibo::lastError = 1;
wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE;
}
}

75
dll/kernel32/fileapi.cpp
View File

@ -111,8 +111,7 @@ bool computeFullPath(const std::string &input, FullPathInfo &outInfo) {
std::error_code ec;
std::filesystem::path absPath = std::filesystem::absolute(hostPath, ec);
if (ec) {
errno = ec.value();
kernel32::setLastErrorFromErrno();
wibo::lastError = wibo::winErrorFromErrno(ec.value());
return false;
}
@ -266,7 +265,6 @@ bool tryOpenConsoleDevice(DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCrea
outHandle = INVALID_HANDLE_VALUE;
return true;
}
wibo::lastError = ERROR_SUCCESS;
return true;
}
@ -306,19 +304,16 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
if (endsWith(pathStr, "/license.dat")) {
DEBUG_LOG("MWCC license override\n");
wibo::lastError = ERROR_SUCCESS;
return FILE_ATTRIBUTE_NORMAL;
}
std::error_code ec;
auto status = std::filesystem::status(path, ec);
if (ec) {
errno = ec.value();
setLastErrorFromErrno();
wibo::lastError = wibo::winErrorFromErrno(ec.value());
return INVALID_FILE_ATTRIBUTES;
}
wibo::lastError = ERROR_SUCCESS;
switch (status.type()) {
case std::filesystem::file_type::regular:
DEBUG_LOG("File exists\n");
@ -348,7 +343,6 @@ UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeA(%s)\n", lpRootPathName ? lpRootPathName : "(null)");
(void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
return DRIVE_FIXED;
}
@ -356,7 +350,6 @@ UINT WIN_FUNC GetDriveTypeW(LPCWSTR lpRootPathName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeW(%p)\n", lpRootPathName);
(void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
return DRIVE_FIXED;
}
@ -386,7 +379,6 @@ BOOL WIN_FUNC GetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuf
lpFileSystemNameBuffer[copyLen] = '\0';
}
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -418,7 +410,6 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB
lpFileSystemNameBuffer[copyLen] = 0;
}
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -448,7 +439,6 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
HOST_CONTEXT_GUARD();
DEBUG_LOG("WriteFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten,
lpOverlapped);
wibo::lastError = ERROR_SUCCESS;
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@ -514,7 +504,6 @@ BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) {
setLastErrorFromErrno();
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -523,7 +512,6 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
HOST_CONTEXT_GUARD();
DEBUG_LOG("ReadFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead,
lpOverlapped);
wibo::lastError = ERROR_SUCCESS;
HandleMeta 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) ||
(dwCreationDisposition == CREATE_ALWAYS && existedBefore)) {
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);
@ -837,12 +823,11 @@ BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) {
}
std::string path = files::pathFromWindows(lpFileName);
DEBUG_LOG("DeleteFileA(%s) -> %s\n", lpFileName, path.c_str());
if (unlink(path.c_str()) == 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
if (unlink(path.c_str()) != 0) {
setLastErrorFromErrno();
return FALSE;
}
setLastErrorFromErrno();
return FALSE;
return TRUE;
}
BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) {
@ -872,17 +857,14 @@ BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) {
return FALSE;
}
if (ec) {
errno = ec.value();
setLastErrorFromErrno();
wibo::lastError = wibo::winErrorFromErrno(ec.value());
return FALSE;
}
std::filesystem::rename(fromPath, toPath, ec);
if (ec) {
errno = ec.value();
setLastErrorFromErrno();
wibo::lastError = wibo::winErrorFromErrno(ec.value());
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -935,7 +917,6 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan
if (lpDistanceToMoveHigh) {
*lpDistanceToMoveHigh = static_cast<LONG>(static_cast<uint64_t>(position) >> 32);
}
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(static_cast<uint64_t>(position) & 0xFFFFFFFFu);
}
@ -1005,7 +986,6 @@ BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) {
setLastErrorFromErrno();
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1018,12 +998,11 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri
}
std::string path = files::pathFromWindows(lpPathName);
DEBUG_LOG("CreateDirectoryA(%s, %p)\n", path.c_str(), lpSecurityAttributes);
if (mkdir(path.c_str(), 0755) == 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
if (mkdir(path.c_str(), 0755) != 0) {
setLastErrorFromErrno();
return FALSE;
}
setLastErrorFromErrno();
return FALSE;
return TRUE;
}
BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
@ -1034,12 +1013,11 @@ BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
}
std::string path = files::pathFromWindows(lpPathName);
DEBUG_LOG("RemoveDirectoryA(%s)\n", path.c_str());
if (rmdir(path.c_str()) == 0) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
if (rmdir(path.c_str()) != 0) {
setLastErrorFromErrno();
return FALSE;
}
setLastErrorFromErrno();
return FALSE;
return TRUE;
}
BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
@ -1050,7 +1028,6 @@ BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
return FALSE;
}
DEBUG_LOG("STUB: SetFileAttributesA(%s, %u)\n", lpFileName, dwFileAttributes);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1077,7 +1054,6 @@ DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
if (lpFileSizeHigh) {
*lpFileSizeHigh = static_cast<DWORD>(uSize >> 32);
}
wibo::lastError = ERROR_SUCCESS;
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;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1144,7 +1119,6 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
bool changeAccess = !shouldIgnoreFileTimeParam(lpLastAccessTime);
bool changeWrite = !shouldIgnoreFileTimeParam(lpLastWriteTime);
if (!changeAccess && !changeWrite) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
struct stat st{};
@ -1192,7 +1166,6 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
if (!shouldIgnoreFileTimeParam(lpCreationTime) && lpCreationTime) {
DEBUG_LOG("SetFileTime: creation time not supported\n");
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1231,7 +1204,6 @@ BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMAT
lpFileInformation->nNumberOfLinks = 0;
lpFileInformation->nFileIndexHigh = 0;
lpFileInformation->nFileIndexLow = 0;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1250,7 +1222,6 @@ DWORD WIN_FUNC GetFileType(HANDLE hFile) {
DEBUG_LOG("-> fstat error\n");
return FILE_TYPE_UNKNOWN;
}
wibo::lastError = ERROR_SUCCESS;
DWORD type = FILE_TYPE_UNKNOWN;
if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode) || S_ISBLK(st.st_mode)) {
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);
}
@ -1368,7 +1338,6 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR
}
}
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(wideLen - 1);
}
@ -1389,7 +1358,6 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
}
strcpy(lpszShortPath, absStr.c_str());
wibo::lastError = ERROR_SUCCESS;
return required - 1;
}
@ -1411,7 +1379,6 @@ DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWO
return required;
}
wstrncpy(lpszShortPath, absStrW.data(), len + 1);
wibo::lastError = ERROR_SUCCESS;
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());
strncpy(lpTempFileName, str.c_str(), MAX_PATH);
lpTempFileName[MAX_PATH - 1] = '\0';
wibo::lastError = ERROR_SUCCESS;
return uUnique;
}
@ -1482,7 +1448,6 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
DEBUG_LOG(" -> %s\n", path);
strncpy(lpBuffer, path, nBufferLength);
lpBuffer[nBufferLength - 1] = '\0';
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(len);
}
@ -1503,7 +1468,6 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
setCommonFindDataFields(*lpFindFileData);
if (status.type() == std::filesystem::file_type::regular) {
setFindFileDataFromPath(hostPath, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return kPseudoFindHandle;
}
@ -1525,7 +1489,6 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
}
setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HANDLE>(handle);
}
@ -1547,7 +1510,6 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
setCommonFindDataFields(*lpFindFileData);
if (status.type() == std::filesystem::file_type::regular) {
setFindFileDataFromPath(hostPath, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return kPseudoFindHandle;
}
@ -1569,7 +1531,6 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
}
setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HANDLE>(handle);
}
@ -1610,7 +1571,6 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
}
setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1639,7 +1599,6 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
}
setFindFileDataFromPath(match, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1647,7 +1606,6 @@ BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("FindClose(%p)\n", hFindFile);
if (isPseudoHandle(hFindFile) || hFindFile == nullptr) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1657,7 +1615,6 @@ BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
return FALSE;
}
delete handle;
wibo::lastError = ERROR_SUCCESS;
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);
DEBUG_LOG("DuplicateHandle: created process handle for current process -> %p\n", handle);
*lpTargetHandle = handle;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
} else if (isPseudoCurrentThreadHandle(hSourceHandle)) {
auto th = make_pin<ThreadObject>(pthread_self());
auto handle = wibo::handles().alloc(std::move(th), 0, 0);
DEBUG_LOG("DuplicateHandle: created thread handle for current thread -> %p\n", handle);
*lpTargetHandle = handle;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -58,7 +56,6 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -69,7 +66,6 @@ BOOL WIN_FUNC CloseHandle(HANDLE hObject) {
wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
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)) {
kernel32::tryMarkExecutable(mem);
}
wibo::lastError = ERROR_SUCCESS;
return mem;
}
@ -99,7 +98,6 @@ HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaxim
record->isProcessHeap = false;
HANDLE handle = wibo::handles().alloc(std::move(record), 0, 0);
wibo::lastError = ERROR_SUCCESS;
return handle;
}
@ -118,14 +116,12 @@ BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) {
}
mi_heap_destroy(record->heap);
record->heap = nullptr;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
HANDLE WIN_FUNC GetProcessHeap() {
HOST_CONTEXT_GUARD();
ensureProcessHeapInitialized();
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("GetProcessHeap() -> %p\n", g_processHeapHandle);
return g_processHeapHandle;
}
@ -152,11 +148,9 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI
return FALSE;
}
record->compatibility = *static_cast<ULONG *>(HeapInformation);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
case HeapEnableTerminationOnCorruption:
wibo::lastError = ERROR_SUCCESS;
return TRUE;
case HeapOptimizeResources:
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) {
void *alloc = heapAllocFromRecord(record.get(), dwFlags, dwBytes);
DEBUG_LOG("-> %p (alloc)\n", alloc);
wibo::lastError = ERROR_SUCCESS;
return alloc;
}
// 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) {
mi_free(lpMem);
DEBUG_LOG("-> NULL (freed)\n");
wibo::lastError = ERROR_SUCCESS;
return nullptr;
}
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;
}
DEBUG_LOG("-> %p (in-place)\n", lpMem);
wibo::lastError = ERROR_SUCCESS;
return lpMem;
}
@ -260,7 +251,6 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
if (isExecutableHeap(record.get())) {
tryMarkExecutable(ret);
}
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("-> %p\n", ret);
return ret;
}
@ -289,7 +279,6 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
return static_cast<SIZE_T>(-1);
}
size_t size = mi_usable_size(lpMem);
wibo::lastError = ERROR_SUCCESS;
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);
(void)dwFlags;
if (lpMem == nullptr) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
auto record = wibo::handles().getAs<HeapObject>(hHeap);
@ -320,7 +308,6 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
}
mi_free(lpMem);
DEBUG_LOG("-> SUCCESS\n");
wibo::lastError = ERROR_SUCCESS;
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) {
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
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;
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -60,7 +59,6 @@ HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) {
wibo::lastError = ERROR_MOD_NOT_FOUND;
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
return module->handle;
}
@ -107,7 +105,6 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
return nSize;
}
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(copyLen);
}
@ -149,7 +146,6 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
return nSize;
}
wibo::lastError = ERROR_SUCCESS;
return static_cast<DWORD>(copyLen);
}
@ -239,7 +235,6 @@ HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) {
// lastError is set by loadModule
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
return info->handle;
}
@ -293,8 +288,6 @@ FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
DEBUG_LOG("-> %p\n", result);
if (!result) {
wibo::lastError = ERROR_PROC_NOT_FOUND;
} else {
wibo::lastError = ERROR_SUCCESS;
}
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;
}
wibo::lastError = ERROR_SUCCESS;
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);
g_viewInfo.emplace(view.viewBase, std::move(view));
}
wibo::lastError = ERROR_SUCCESS;
return viewPtr;
}
@ -708,7 +706,6 @@ BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) {
if (length != 0) {
munmap(base, length);
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -766,10 +763,9 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
int advice = MADV_DONTNEED;
#endif
if (madvise(reinterpret_cast<void *>(start), length, advice) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return nullptr;
}
wibo::lastError = ERROR_SUCCESS;
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);
}
if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return nullptr;
}
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.pageProtect.assign(length / pageSize, commit ? flProtect : 0);
g_virtualAllocations[actualBase] = std::move(allocation);
wibo::lastError = ERROR_SUCCESS;
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),
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return nullptr;
}
markCommitted(*region, run.first, run.second, flProtect);
}
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("VirtualAlloc commit success -> %p\n", reinterpret_cast<void *>(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);
lk.unlock();
if (munmap(lpAddress, length) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
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,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_NORESERVE, -1, 0);
if (result == MAP_FAILED) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return FALSE;
}
markDecommitted(region, start, length);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1040,7 +1032,7 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
int prot = translateProtect(flNewProtect);
if (mprotect(reinterpret_cast<void *>(start), end - start, prot) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastErrorFromErrno();
return FALSE;
}
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) {
*lpflOldProtect = previousProtect;
}
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1077,17 +1068,14 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
MEMORY_BASIC_INFORMATION info{};
if (moduleRegionForAddress(pageBase, info)) {
*lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
return sizeof(MEMORY_BASIC_INFORMATION);
}
if (mappedViewRegionForAddress(request, pageBase, info)) {
*lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
return sizeof(MEMORY_BASIC_INFORMATION);
}
if (virtualAllocationRegionForAddress(pageBase, info)) {
*lpBuffer = info;
wibo::lastError = ERROR_SUCCESS;
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
*lpMaximumWorkingSetSize = 128 * 1024 * 1024; // 128 MiB stub
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -1118,7 +1105,6 @@ BOOL WIN_FUNC SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T dwMinimumWorkingS
(void)hProcess;
(void)dwMinimumWorkingSetSize;
(void)dwMaximumWorkingSetSize;
wibo::lastError = ERROR_SUCCESS;
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;
*hReadPipe = wibo::handles().alloc(std::move(readObj), FILE_GENERIC_READ, 0);
*hWritePipe = wibo::handles().alloc(std::move(writeObj), FILE_GENERIC_WRITE, 0);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}

14
dll/kernel32/processenv.cpp
View File

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

21
dll/kernel32/processthreadsapi.cpp
View File

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

2
dll/kernel32/profileapi.cpp
View File

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

12
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);
}
wibo::lastError = ERROR_SUCCESS;
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]));
}
BOOL result = TRUE;
if (length > 0) {
result = GetStringTypeW(dwInfoType, wide.data(), length, lpCharType);
} else {
result = TRUE;
}
wibo::lastError = result ? ERROR_SUCCESS : wibo::lastError;
return result;
return GetStringTypeW(dwInfoType, wide.data(), length, lpCharType);
}
return TRUE;
}
} // namespace kernel32

8
dll/kernel32/synchapi.cpp
View File

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

1
dll/kernel32/sysinfoapi.cpp
View File

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

7
dll/kernel32/timezoneapi.cpp
View File

@ -33,7 +33,6 @@ BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lp
return FALSE;
}
*lpFileTime = result;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -63,7 +62,6 @@ BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSy
lpSystemTime->wMinute = static_cast<WORD>((secondsOfDay % 3600U) / 60U);
lpSystemTime->wSecond = static_cast<WORD>(secondsOfDay % 60U);
lpSystemTime->wMilliseconds = static_cast<WORD>(hundredNs / HUNDRED_NS_PER_MILLISECOND);
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -113,7 +111,6 @@ BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpL
return FALSE;
}
*lpLocalFileTime = result;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -156,7 +153,6 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM
return FALSE;
}
*lpFileTime = result;
wibo::lastError = ERROR_SUCCESS;
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;
*lpFileTime = fileTimeFromDuration(ticks);
wibo::lastError = ERROR_SUCCESS;
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);
*lpFatTime = static_cast<WORD>(((tmValue.tm_hour & 0x1F) << 11) | ((tmValue.tm_min & 0x3F) << 5) |
((tmValue.tm_sec / 2) & 0x1F));
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
@ -279,7 +273,6 @@ DWORD WIN_FUNC GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformat
} else {
result = TIME_ZONE_ID_STANDARD;
}
wibo::lastError = ERROR_SUCCESS;
return result;
}

42
dll/kernel32/winbase.cpp
View File

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

9
dll/kernel32/wincon.cpp
View File

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

22
dll/kernel32/winnls.cpp
View File

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

3
dll/kernel32/wow64apiset.cpp
View File

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

5
dll/user32.cpp
View File

@ -129,14 +129,12 @@ namespace user32 {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetKeyboardLayout(%u)\n", idThread);
(void)idThread;
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HKL>(kDefaultKeyboardLayout);
}
HWINSTA WIN_FUNC GetProcessWindowStation() {
DEBUG_LOG("GetProcessWindowStation()\n");
static int kWindowStationStub;
wibo::lastError = ERROR_SUCCESS;
return reinterpret_cast<HWINSTA>(&kWindowStationStub);
}
@ -164,14 +162,11 @@ namespace user32 {
flags->fInherit = FALSE;
flags->fReserved = FALSE;
flags->dwFlags = WSF_VISIBLE;
wibo::lastError = ERROR_SUCCESS;
return TRUE;
}
HWND WIN_FUNC GetActiveWindow() {
DEBUG_LOG("GetActiveWindow()\n");
wibo::lastError = ERROR_SUCCESS;
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);
buffer.assign(start, start + loc.size);
wibo::lastError = ERROR_SUCCESS;
return true;
}
@ -235,7 +234,6 @@ unsigned int WIN_FUNC GetFileVersionInfoA(const char *lptstrFilename, unsigned i
if (buffer.size() < dwLen) {
std::memset(static_cast<uint8_t *>(lpData) + buffer.size(), 0, dwLen - buffer.size());
}
wibo::lastError = ERROR_SUCCESS;
return 1;
}

3
src/main.cpp
View File

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

43
test/test_actctx.c
View File

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