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

Refactor to use TIB LastErrorValue

Browse Source
This commit is contained in:
Luke Street
2025-10-28 10:01:21 -06:00
parent 8bd15bd272
commit 9367f003c5
34 changed files with 785 additions and 745 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
dll/advapi32/processthreadsapi.cpp
View File

@@ -14,7 +14,7 @@ BOOL WIN_FUNC OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDL
HOST_CONTEXT_GUARD();
DEBUG_LOG("OpenProcessToken(%p, %u, %p)\n", ProcessHandle, DesiredAccess, TokenHandle);
if (!TokenHandle) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
Pin<ProcessObject> obj;
@@ -24,7 +24,7 @@ BOOL WIN_FUNC OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDL
obj = wibo::handles().getAs<ProcessObject>(ProcessHandle);
}
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
auto token = make_pin<TokenObject>(std::move(obj), DesiredAccess);

93
dll/advapi32/securitybaseapi.cpp
View File

@@ -5,6 +5,7 @@
#include "errors.h"
#include "handles.h"
#include "internal.h"
#include "kernel32/internal.h"
#include <algorithm>
#include <cstring>
@@ -106,11 +107,11 @@ BOOL WIN_FUNC InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("InitializeAcl(%p, %u, %u)\n", pAcl, nAclLength, dwAclRevision);
if (!pAcl) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (nAclLength < sizeof(ACL) || nAclLength > std::numeric_limits<WORD>::max() || (nAclLength & 0x3) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
BYTE revision = static_cast<BYTE>(dwAclRevision);
@@ -121,7 +122,7 @@ BOOL WIN_FUNC InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision) {
case ACL_REVISION4:
break;
default:
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pAcl->AclRevision = revision;
@@ -136,7 +137,7 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa
HOST_CONTEXT_GUARD();
DEBUG_LOG("AddAccessAllowedAce(%p, %u, 0x%x, %p)\n", pAcl, dwAceRevision, AccessMask, pSid);
if (!pAcl || !pSid) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
BYTE revision = static_cast<BYTE>(dwAceRevision);
@@ -147,25 +148,25 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa
case ACL_REVISION4:
break;
default:
wibo::lastError = ERROR_REVISION_MISMATCH;
kernel32::setLastError(ERROR_REVISION_MISMATCH);
return FALSE;
}
if (pAcl->AclRevision < revision) {
wibo::lastError = ERROR_REVISION_MISMATCH;
kernel32::setLastError(ERROR_REVISION_MISMATCH);
return FALSE;
}
if (pAcl->AceCount == std::numeric_limits<WORD>::max()) {
wibo::lastError = ERROR_ALLOTTED_SPACE_EXCEEDED;
kernel32::setLastError(ERROR_ALLOTTED_SPACE_EXCEEDED);
return FALSE;
}
size_t capacity = pAcl->Sbz2 ? pAcl->Sbz2 : pAcl->AclSize;
if (capacity < sizeof(ACL)) {
wibo::lastError = ERROR_INVALID_ACL;
kernel32::setLastError(ERROR_INVALID_ACL);
return FALSE;
}
size_t used = 0;
if (!computeAclUsedSize(pAcl, capacity, used)) {
wibo::lastError = ERROR_INVALID_ACL;
kernel32::setLastError(ERROR_INVALID_ACL);
return FALSE;
}
if (used > pAcl->AclSize) {
@@ -175,17 +176,17 @@ BOOL WIN_FUNC AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMa
const auto *sid = reinterpret_cast<const Sid *>(pSid);
size_t sidLen = sidLength(sid);
if (sidLen == 0 || sidLen > capacity) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return FALSE;
}
size_t aceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + sidLen;
aceSize = alignToDword(aceSize);
if (aceSize > std::numeric_limits<WORD>::max()) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return FALSE;
}
if (used + aceSize > capacity) {
wibo::lastError = ERROR_ALLOTTED_SPACE_EXCEEDED;
kernel32::setLastError(ERROR_ALLOTTED_SPACE_EXCEEDED);
return FALSE;
}
auto *dest = reinterpret_cast<BYTE *>(pAcl) + used;
@@ -205,18 +206,18 @@ BOOL WIN_FUNC FindFirstFreeAce(PACL pAcl, LPVOID *pAce) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("FindFirstFreeAce(%p, %p)\n", pAcl, pAce);
if (!pAce) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*pAce = nullptr;
if (!pAcl) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
size_t capacity = pAcl->Sbz2 ? pAcl->Sbz2 : pAcl->AclSize;
size_t used = 0;
if (!computeAclUsedSize(pAcl, capacity, used)) {
wibo::lastError = ERROR_INVALID_ACL;
kernel32::setLastError(ERROR_INVALID_ACL);
return FALSE;
}
*pAce = reinterpret_cast<BYTE *>(pAcl) + used;
@@ -230,15 +231,15 @@ BOOL WIN_FUNC GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
DEBUG_LOG("GetSecurityDescriptorDacl(%p, %p, %p, %p)\n", pSecurityDescriptor, lpbDaclPresent, pDacl,
lpbDaclDefaulted);
if (!pSecurityDescriptor) {
wibo::lastError = ERROR_INVALID_SECURITY_DESCR;
kernel32::setLastError(ERROR_INVALID_SECURITY_DESCR);
return FALSE;
}
if (!lpbDaclPresent) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (pSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION) {
wibo::lastError = ERROR_INVALID_SECURITY_DESCR;
kernel32::setLastError(ERROR_INVALID_SECURITY_DESCR);
return FALSE;
}
BOOL hasDacl = (pSecurityDescriptor->Control & SE_DACL_PRESENT) ? TRUE : FALSE;
@@ -265,12 +266,12 @@ PSID_IDENTIFIER_AUTHORITY WIN_FUNC GetSidIdentifierAuthority(PSID pSid) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetSidIdentifierAuthority(%p)\n", pSid);
if (!pSid) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
auto *sid = reinterpret_cast<Sid *>(pSid);
if (sid->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
return reinterpret_cast<PSID_IDENTIFIER_AUTHORITY>(&sid->IdentifierAuthority);
@@ -280,12 +281,12 @@ PUCHAR WIN_FUNC GetSidSubAuthorityCount(PSID pSid) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetSidSubAuthorityCount(%p)\n", pSid);
if (!pSid) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
auto *sid = reinterpret_cast<Sid *>(pSid);
if (sid->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
return &sid->SubAuthorityCount;
@@ -295,12 +296,12 @@ PDWORD WIN_FUNC GetSidSubAuthority(PSID pSid, DWORD nSubAuthority) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetSidSubAuthority(%p, %u)\n", pSid, nSubAuthority);
if (!pSid) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
auto *sid = reinterpret_cast<Sid *>(pSid);
if (sid->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES || nSubAuthority >= sid->SubAuthorityCount) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return nullptr;
}
return &sid->SubAuthority[nSubAuthority];
@@ -322,12 +323,12 @@ BOOL WIN_FUNC DuplicateTokenEx(HANDLE hExistingToken, DWORD dwDesiredAccess, voi
(void)ImpersonationLevel;
(void)TokenType;
if (!phNewToken) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto existing = wibo::handles().getAs<TokenObject>(hExistingToken);
if (!existing) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
auto newToken =
@@ -340,13 +341,13 @@ BOOL WIN_FUNC CopySid(DWORD nDestinationSidLength, PSID pDestinationSid, PSID pS
HOST_CONTEXT_GUARD();
DEBUG_LOG("CopySid(%u, %p, %p)\n", nDestinationSidLength, pDestinationSid, pSourceSid);
if (!pDestinationSid || !pSourceSid) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto *source = reinterpret_cast<Sid *>(pSourceSid);
size_t required = sidLength(source);
if (required == 0 || required > nDestinationSidLength) {
wibo::lastError = ERROR_ALLOTTED_SPACE_EXCEEDED;
kernel32::setLastError(ERROR_ALLOTTED_SPACE_EXCEEDED);
return FALSE;
}
std::memcpy(pDestinationSid, pSourceSid, required);
@@ -357,11 +358,11 @@ BOOL WIN_FUNC InitializeSid(PSID sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAutho
HOST_CONTEXT_GUARD();
DEBUG_LOG("InitializeSid(%p, %p, %u)\n", sid, pIdentifierAuthority, nSubAuthorityCount);
if (!sid || !pIdentifierAuthority) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (nSubAuthorityCount > SID_MAX_SUB_AUTHORITIES) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return FALSE;
}
auto *sidStruct = reinterpret_cast<Sid *>(sid);
@@ -378,13 +379,13 @@ BOOL WIN_FUNC EqualSid(PSID pSid1, PSID pSid2) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("EqualSid(%p, %p)\n", pSid1, pSid2);
if (!pSid1 || !pSid2) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return FALSE;
}
const auto *sid1 = reinterpret_cast<const Sid *>(pSid1);
const auto *sid2 = reinterpret_cast<const Sid *>(pSid2);
if (sid1->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES || sid2->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES) {
wibo::lastError = ERROR_INVALID_SID;
kernel32::setLastError(ERROR_INVALID_SID);
return FALSE;
}
bool equal =
@@ -403,12 +404,12 @@ BOOL WIN_FUNC SetKernelObjectSecurity(HANDLE Handle, SECURITY_INFORMATION Securi
DEBUG_LOG("STUB: SetKernelObjectSecurity(%p, 0x%x, %p)\n", Handle, SecurityInformation, SecurityDescriptor);
(void)SecurityInformation;
if (!SecurityDescriptor) {
wibo::lastError = ERROR_INVALID_SECURITY_DESCR;
kernel32::setLastError(ERROR_INVALID_SECURITY_DESCR);
return FALSE;
}
auto obj = wibo::handles().get(Handle);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;
@@ -418,7 +419,7 @@ BOOL WIN_FUNC InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescrip
HOST_CONTEXT_GUARD();
DEBUG_LOG("InitializeSecurityDescriptor(%p, %u)\n", pSecurityDescriptor, dwRevision);
if (!pSecurityDescriptor || dwRevision != SECURITY_DESCRIPTOR_REVISION) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pSecurityDescriptor->Revision = static_cast<BYTE>(dwRevision);
@@ -436,7 +437,7 @@ BOOL WIN_FUNC SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetSecurityDescriptorDacl(%p, %u, %p, %u)\n", pSecurityDescriptor, bDaclPresent, pDacl, bDaclDefaulted);
if (!pSecurityDescriptor || pSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
WORD control = static_cast<WORD>(pSecurityDescriptor->Control & ~(SE_DACL_PRESENT | SE_DACL_DEFAULTED));
@@ -459,12 +460,12 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
DEBUG_LOG("STUB: GetTokenInformation(%p, %u, %p, %u, %p)\n", TokenHandle, TokenInformationClass, TokenInformation,
TokenInformationLength, ReturnLength);
if (!ReturnLength) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto token = wibo::handles().getAs<TokenObject>(TokenHandle);
if (!token) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
*ReturnLength = 0;
@@ -474,13 +475,13 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
DWORD required = static_cast<DWORD>(tokenUserSize + sidSize);
*ReturnLength = required;
if (!TokenInformation || TokenInformationLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
auto *tokenUser = reinterpret_cast<TokenUserData *>(TokenInformation);
auto *sid = reinterpret_cast<Sid *>(reinterpret_cast<BYTE *>(TokenInformation) + tokenUserSize);
if (!writeLocalSystemSid(sid)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
tokenUser->User.SidPtr = sid;
@@ -491,7 +492,7 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
DWORD required = sizeof(TokenStatisticsData);
*ReturnLength = required;
if (!TokenInformation || TokenInformationLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
auto *stats = reinterpret_cast<TokenStatisticsData *>(TokenInformation);
@@ -507,7 +508,7 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
DWORD required = sizeof(DWORD);
*ReturnLength = required;
if (!TokenInformation || TokenInformationLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
*reinterpret_cast<DWORD *>(TokenInformation) = 0; // not elevated
@@ -517,19 +518,19 @@ BOOL WIN_FUNC GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
DWORD required = static_cast<DWORD>(sizeof(TokenPrimaryGroupStub) + sizeof(Sid));
*ReturnLength = required;
if (!TokenInformation || TokenInformationLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
auto *groupInfo = reinterpret_cast<TokenPrimaryGroupStub *>(TokenInformation);
auto *sid = reinterpret_cast<Sid *>(reinterpret_cast<BYTE *>(TokenInformation) + sizeof(TokenPrimaryGroupStub));
if (!writeLocalSystemSid(sid)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
groupInfo->PrimaryGroup = sid;
return TRUE;
}
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
@@ -557,7 +558,7 @@ BOOL WIN_FUNC SetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS To
(void)TokenInformationLength;
auto token = wibo::handles().getAs<TokenObject>(TokenHandle);
if (!token) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;

19
dll/advapi32/winbase.cpp
View File

@@ -4,6 +4,7 @@
#include "context.h"
#include "errors.h"
#include "internal.h"
#include "kernel32/internal.h"
#include "strutil.h"
#include <algorithm>
@@ -90,12 +91,12 @@ BOOL WIN_FUNC LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPD
DEBUG_LOG("LookupAccountSidW(%s, %p, %p, %p, %p, %p, %p)\n", systemName.c_str(), Sid, Name, cchName,
ReferencedDomainName, cchReferencedDomainName, peUse);
if (!Sid || !cchName || !cchReferencedDomainName || !peUse) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto *sidStruct = reinterpret_cast<const struct Sid *>(Sid);
if (!isLocalSystemSid(sidStruct)) {
wibo::lastError = ERROR_NONE_MAPPED;
kernel32::setLastError(ERROR_NONE_MAPPED);
return FALSE;
}
DWORD requiredAccount = static_cast<DWORD>(wstrlen(kAccountSystem));
@@ -103,7 +104,7 @@ BOOL WIN_FUNC LookupAccountSidW(LPCWSTR lpSystemName, PSID Sid, LPWSTR Name, LPD
if (!Name || *cchName <= requiredAccount || !ReferencedDomainName || *cchReferencedDomainName <= requiredDomain) {
*cchName = requiredAccount + 1;
*cchReferencedDomainName = requiredDomain + 1;
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
std::copy_n(kAccountSystem, requiredAccount + 1, Name);
@@ -120,7 +121,7 @@ BOOL WIN_FUNC LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lp
lpLuid);
(void)lpSystemName; // only local lookup supported
if (!lpName || !lpLuid) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string normalized = normalizePrivilegeName(lpName);
@@ -134,7 +135,7 @@ BOOL WIN_FUNC LookupPrivilegeValueW(LPCWSTR lpSystemName, LPCWSTR lpName, PLUID
DEBUG_LOG("LookupPrivilegeValueW(%p, %p, %p)\n", lpSystemName, lpName, lpLuid);
(void)lpSystemName; // only local lookup supported
if (!lpName || !lpLuid) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string ansiName = wideStringToString(lpName);
@@ -148,14 +149,14 @@ BOOL WIN_FUNC GetUserNameA(LPSTR lpBuffer, LPDWORD pcbBuffer) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetUserNameA(%p, %p)\n", lpBuffer, pcbBuffer);
if (!pcbBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
const char *name = "SYSTEM";
size_t needed = std::strlen(name) + 1;
if (!lpBuffer || *pcbBuffer < needed) {
*pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
std::memcpy(lpBuffer, name, needed);
@@ -167,13 +168,13 @@ BOOL WIN_FUNC GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetUserNameW(%p, %p)\n", lpBuffer, pcbBuffer);
if (!pcbBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
size_t needed = wstrlen(kAccountSystem) + 1;
if (!lpBuffer || *pcbBuffer < needed) {
*pcbBuffer = static_cast<DWORD>(needed);
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
std::memcpy(lpBuffer, kAccountSystem, needed * sizeof(WCHAR));

39
dll/advapi32/wincrypt.cpp
View File

@@ -3,6 +3,7 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "kernel32/internal.h"
#include "md5.h"
#define SHA1_IMPLEMENTATION
@@ -75,7 +76,7 @@ BOOL WIN_FUNC CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPC
// to quote the guy above me: screw them for now
static int dummyProvider = 42;
if (!phProv) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*phProv = static_cast<HCRYPTPROV>(reinterpret_cast<uintptr_t>(&dummyProvider));
@@ -87,13 +88,13 @@ BOOL WIN_FUNC CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer) {
DEBUG_LOG("CryptGenRandom(%p)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hProv)));
(void)hProv;
if (!pbBuffer || dwLen == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ssize_t ret = getrandom(pbBuffer, dwLen, 0);
if (ret < 0 || static_cast<DWORD>(ret) != dwLen) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
@@ -106,19 +107,19 @@ BOOL WIN_FUNC CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DW
reinterpret_cast<void *>(static_cast<uintptr_t>(hKey)), dwFlags, phHash);
(void)hProv;
if (!phHash) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (dwFlags != 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
if (hKey != 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
if (Algid != CALG_MD5 && Algid != CALG_SHA1) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
auto *hash = new HashObject;
@@ -137,12 +138,12 @@ BOOL WIN_FUNC CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLe
DEBUG_LOG("CryptHashData(%p, %p, %u, %u)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hHash)), pbData,
dwDataLen, dwFlags);
if (dwFlags != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto *hash = hashObjectFromHandle(hHash);
if (!hash || (dwDataLen != 0 && !pbData)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (pbData && dwDataLen) {
@@ -160,12 +161,12 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
DEBUG_LOG("CryptGetHashParam(%p, %u, %p, %p, %u)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hHash)),
dwParam, pbData, pdwDataLen, dwFlags);
if (dwFlags != 0 || !pdwDataLen) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto *hash = hashObjectFromHandle(hHash);
if (!hash) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
switch (dwParam) {
@@ -177,7 +178,7 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
if (*pdwDataLen < required) {
*pdwDataLen = required;
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
memcpy(pbData, &hash->algid, required);
@@ -192,12 +193,12 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
if (*pdwDataLen < required) {
*pdwDataLen = required;
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
DWORD size = hashSizeForAlgid(hash->algid);
if (size == 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
memcpy(pbData, &size, required);
@@ -206,12 +207,12 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
case HP_HASHVAL: {
if (!computeDigest(*hash)) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
DWORD size = hashSizeForAlgid(hash->algid);
if (size == 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
if (!pbData) {
@@ -220,7 +221,7 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
}
if (*pdwDataLen < size) {
*pdwDataLen = size;
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
memcpy(pbData, hash->digest, size);
@@ -228,7 +229,7 @@ BOOL WIN_FUNC CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, D
return TRUE;
}
default:
wibo::lastError = ERROR_NOT_SUPPORTED;
kernel32::setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
}
@@ -238,7 +239,7 @@ BOOL WIN_FUNC CryptDestroyHash(HCRYPTHASH hHash) {
DEBUG_LOG("CryptDestroyHash(%p)\n", reinterpret_cast<void *>(static_cast<uintptr_t>(hHash)));
auto *hash = hashObjectFromHandle(hHash);
if (!hash) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
delete hash;

35
dll/advapi32/winreg.cpp
View File

@@ -4,6 +4,7 @@
#include "context.h"
#include "errors.h"
#include "handles.h"
#include "kernel32/internal.h"
#include "strutil.h"
#include <algorithm>
@@ -135,17 +136,17 @@ LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LP
(void)lpClass;
(void)lpSecurityAttributes;
if (!phkResult) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
*phkResult = nullptr;
if (Reserved != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
if (dwOptions != 0) {
DEBUG_LOG("RegCreateKeyExW: unsupported options 0x%x\n", dwOptions);
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
REGSAM sanitizedAccess = samDesired & ~(KEY_WOW64_64KEY | KEY_WOW64_32KEY);
@@ -155,7 +156,7 @@ LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LP
std::lock_guard<std::mutex> lock(g_registryMutex);
Pin<RegistryKeyObject> baseHandle = handleDataFromHKeyLocked(hKey);
if (!baseHandle) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return ERROR_INVALID_HANDLE;
}
std::u16string targetPath = baseHandle->canonicalPath;
@@ -171,7 +172,7 @@ LSTATUS WIN_FUNC RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LP
}
}
if (targetPath.empty()) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return ERROR_INVALID_HANDLE;
}
bool existed = g_existingKeys.find(targetPath) != g_existingKeys.end();
@@ -216,12 +217,12 @@ LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REG
std::string subKeyString = lpSubKey ? wideStringToString(lpSubKey) : std::string("(null)");
DEBUG_LOG("RegOpenKeyExW(%p, %s, %u, 0x%x, %p)\n", hKey, subKeyString.c_str(), ulOptions, samDesired, phkResult);
if (!phkResult) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
*phkResult = nullptr;
if ((ulOptions & ~REG_OPTION_OPEN_LINK) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
if (ulOptions & REG_OPTION_OPEN_LINK) {
@@ -235,7 +236,7 @@ LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REG
std::lock_guard<std::mutex> lock(g_registryMutex);
Pin<RegistryKeyObject> baseHandle = handleDataFromHKeyLocked(hKey);
if (!baseHandle) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return ERROR_INVALID_HANDLE;
}
std::u16string targetPath = baseHandle->canonicalPath;
@@ -249,11 +250,11 @@ LSTATUS WIN_FUNC RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REG
}
}
if (targetPath.empty()) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return ERROR_INVALID_HANDLE;
}
if (g_existingKeys.find(targetPath) == g_existingKeys.end()) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return ERROR_FILE_NOT_FOUND;
}
if (!lpSubKey || lpSubKey[0] == 0) {
@@ -288,7 +289,7 @@ LSTATUS WIN_FUNC RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpRese
DEBUG_LOG("RegQueryValueExW(%p, %s, %p, %p, %p, %p)\n", hKey, valueName.c_str(), lpReserved, lpType, lpData,
lpcbData);
if (lpReserved) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
if (lpcbData) {
@@ -299,7 +300,7 @@ LSTATUS WIN_FUNC RegQueryValueExW(HKEY hKey, LPCWSTR lpValueName, LPDWORD lpRese
}
(void)hKey;
(void)lpData;
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return ERROR_FILE_NOT_FOUND;
}
@@ -324,7 +325,7 @@ LSTATUS WIN_FUNC RegEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD
(void)hKey;
(void)dwIndex;
if (lpReserved) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
if (lpcchName) {
@@ -340,7 +341,7 @@ LSTATUS WIN_FUNC RegEnumKeyExW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD
*lpcchClass = 0;
}
(void)lpftLastWriteTime;
wibo::lastError = ERROR_NO_MORE_ITEMS;
kernel32::setLastError(ERROR_NO_MORE_ITEMS);
return ERROR_NO_MORE_ITEMS;
}
@@ -352,7 +353,7 @@ LSTATUS WIN_FUNC RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD l
(void)hKey;
(void)dwIndex;
if (lpReserved) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
if (lpcchName) {
@@ -368,7 +369,7 @@ LSTATUS WIN_FUNC RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD l
*lpcchClass = 0;
}
(void)lpftLastWriteTime;
wibo::lastError = ERROR_NO_MORE_ITEMS;
kernel32::setLastError(ERROR_NO_MORE_ITEMS);
return ERROR_NO_MORE_ITEMS;
}
@@ -380,7 +381,7 @@ LSTATUS WIN_FUNC RegCloseKey(HKEY hKey) {
}
auto obj = wibo::handles().getAs<RegistryKeyObject>(hKey);
if (!obj || obj->closed) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return ERROR_INVALID_HANDLE;
}
return ERROR_SUCCESS;

26
dll/kernel32/errhandlingapi.cpp
View File

@@ -14,18 +14,34 @@ UINT g_processErrorMode = 0;
namespace kernel32 {
void setLastErrorFromErrno() { wibo::lastError = wibo::winErrorFromErrno(errno); }
DWORD getLastError() { return wibo::getThreadTibForHost()->lastErrorValue; }
void setLastError(DWORD error) { wibo::getThreadTibForHost()->lastErrorValue = error; }
void setLastErrorFromErrno() { setLastError(wibo::winErrorFromErrno(errno)); }
DWORD WIN_FUNC GetLastError() {
#ifndef NDEBUG
{
HOST_CONTEXT_GUARD();
VERBOSE_LOG("GetLastError() -> %u\n", wibo::lastError);
return wibo::lastError;
DEBUG_LOG("GetLastError() -> %u\n", getLastError());
}
#endif
// In guest context, fetch via TIB
DWORD err;
__asm__ __volatile__("movl %%fs:%c1, %0" : "=r"(err) : "i"(offsetof(TIB, lastErrorValue)));
return err;
}
void WIN_FUNC SetLastError(DWORD dwErrCode) {
#ifndef NDEBUG
{
HOST_CONTEXT_GUARD();
VERBOSE_LOG("SetLastError(%u)\n", dwErrCode);
wibo::lastError = dwErrCode;
DEBUG_LOG("SetLastError(%u)\n", dwErrCode);
}
#endif
// In guest context, store via TIB
__asm__ __volatile__("movl %0, %%fs:%c1" : : "r"(dwErrCode), "i"(offsetof(TIB, lastErrorValue)) : "memory");
}
void WIN_FUNC RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments,

11
dll/kernel32/fibersapi.cpp
View File

@@ -3,6 +3,7 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "internal.h"
namespace {
@@ -27,7 +28,7 @@ DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) {
}
}
DEBUG_LOG(" -> -1\n");
wibo::lastError = FLS_OUT_OF_INDEXES;
setLastError(FLS_OUT_OF_INDEXES);
return FLS_OUT_OF_INDEXES;
}
@@ -38,7 +39,7 @@ BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) {
g_flsValuesUsed[dwFlsIndex] = false;
return TRUE;
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
@@ -50,9 +51,9 @@ PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) {
if (dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) {
result = g_flsValues[dwFlsIndex];
// See https://learn.microsoft.com/en-us/windows/win32/api/fibersapi/nf-fibersapi-flsgetvalue
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
}
// DEBUG_LOG(" -> %p\n", result);
return result;
@@ -65,7 +66,7 @@ BOOL WIN_FUNC FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) {
g_flsValues[dwFlsIndex] = lpFlsData;
return TRUE;
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}

236
dll/kernel32/fileapi.cpp
View File

@@ -109,7 +109,7 @@ bool computeFullPath(const std::string &input, FullPathInfo &outInfo) {
std::error_code ec;
std::filesystem::path absPath = std::filesystem::absolute(hostPath, ec);
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
kernel32::setLastError(wibo::winErrorFromErrno(ec.value()));
return false;
}
@@ -385,7 +385,7 @@ bool collectDirectoryMatches(const std::filesystem::path &directory, const std::
outEntries.push_back(std::move(entry));
}
if (iterEc) {
wibo::lastError = wibo::winErrorFromErrno(iterEc.value());
kernel32::setLastError(wibo::winErrorFromErrno(iterEc.value()));
return false;
}
return true;
@@ -393,12 +393,12 @@ bool collectDirectoryMatches(const std::filesystem::path &directory, const std::
template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawInput, FindData *lpFindFileData) {
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if (rawInput.empty()) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
@@ -406,12 +406,12 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
std::replace(input.begin(), input.end(), '/', '\\');
if (input.empty()) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
if (!input.empty() && input.back() == '\\') {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
@@ -432,12 +432,12 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
}
if (filePart.empty()) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
if (containsWildcardOutsideExtendedPrefix(directoryPart)) {
wibo::lastError = ERROR_INVALID_NAME;
kernel32::setLastError(ERROR_INVALID_NAME);
return INVALID_HANDLE_VALUE;
}
@@ -450,15 +450,15 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
std::error_code dirStatusEc;
auto dirStatus = std::filesystem::status(hostDirectory, dirStatusEc);
if (dirStatusEc) {
wibo::lastError = wibo::winErrorFromErrno(dirStatusEc.value());
kernel32::setLastError(wibo::winErrorFromErrno(dirStatusEc.value()));
return INVALID_HANDLE_VALUE;
}
if (dirStatus.type() == std::filesystem::file_type::not_found) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
if (dirStatus.type() != std::filesystem::file_type::directory) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
@@ -470,11 +470,11 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
std::error_code targetEc;
auto targetStatus = std::filesystem::status(targetPath, targetEc);
if (targetEc) {
wibo::lastError = wibo::winErrorFromErrno(targetEc.value());
kernel32::setLastError(wibo::winErrorFromErrno(targetEc.value()));
return INVALID_HANDLE_VALUE;
}
if (targetStatus.type() == std::filesystem::file_type::not_found) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
@@ -484,7 +484,7 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
entry.name = determineDisplayName(targetPath, filePart);
populateFindData(entry, *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
auto state = std::make_unique<FindSearchHandle>();
state->singleResult = true;
@@ -496,12 +496,12 @@ template <typename FindData> HANDLE findFirstFileCommon(const std::string &rawIn
return INVALID_HANDLE_VALUE;
}
if (matches.empty()) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
populateFindData(matches[0], *lpFindFileData);
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
auto state = std::make_unique<FindSearchHandle>();
state->entries = std::move(matches);
@@ -540,7 +540,7 @@ bool tryOpenConsoleDevice(DWORD dwDesiredAccess, DWORD dwShareMode, DWORD dwCrea
}
HANDLE baseHandle = files::getStdHandle(*stdHandleKind);
if (!wibo::handles().duplicateTo(baseHandle, wibo::handles(), outHandle, dwDesiredAccess, false, 0)) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
@@ -554,7 +554,7 @@ namespace kernel32 {
DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
HOST_CONTEXT_GUARD();
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_FILE_ATTRIBUTES;
}
std::filesystem::path path = files::pathFromWindows(lpFileName);
@@ -569,7 +569,7 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
std::error_code ec;
auto status = std::filesystem::status(path, ec);
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastError(wibo::winErrorFromErrno(ec.value()));
return INVALID_FILE_ATTRIBUTES;
}
@@ -582,7 +582,7 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
case std::filesystem::file_type::not_found:
default:
DEBUG_LOG("File does not exist\n");
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
return INVALID_FILE_ATTRIBUTES;
}
}
@@ -591,7 +591,7 @@ DWORD WIN_FUNC GetFileAttributesW(LPCWSTR lpFileName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetFileAttributesW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_FILE_ATTRIBUTES;
}
std::string str = wideStringToString(lpFileName);
@@ -702,19 +702,19 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
#ifdef CHECK_ACCESS
if ((meta.grantedAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA)) == 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("!!! DENIED: 0x%x\n", meta.grantedAccess);
return FALSE;
}
#endif
if (lpOverlapped == nullptr && lpNumberOfBytesWritten == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -723,7 +723,7 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
}
if (file->overlapped && lpOverlapped == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -749,7 +749,7 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
if (lpNumberOfBytesWritten) {
*lpNumberOfBytesWritten = 0;
}
wibo::lastError = ERROR_IO_PENDING;
setLastError(ERROR_IO_PENDING);
return FALSE;
}
}
@@ -759,7 +759,7 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
NTSTATUS completionStatus = STATUS_SUCCESS;
if (io.unixError != 0) {
completionStatus = wibo::statusFromErrno(io.unixError);
wibo::lastError = wibo::winErrorFromErrno(io.unixError);
setLastError(wibo::winErrorFromErrno(io.unixError));
} else if (io.reachedEnd && io.bytesTransferred == 0) {
completionStatus = STATUS_END_OF_FILE;
}
@@ -778,7 +778,7 @@ BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) {
DEBUG_LOG("FlushFileBuffers(%p)\n", hFile);
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (fsync(file->fd) != 0) {
@@ -797,19 +797,19 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
#ifdef CHECK_ACCESS
if ((meta.grantedAccess & FILE_READ_DATA) == 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("!!! DENIED: 0x%x\n", meta.grantedAccess);
return FALSE;
}
#endif
if (lpOverlapped == nullptr && lpNumberOfBytesRead == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -818,7 +818,7 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
}
if (file->overlapped && lpOverlapped == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -844,7 +844,7 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
if (lpNumberOfBytesRead) {
*lpNumberOfBytesRead = 0;
}
wibo::lastError = ERROR_IO_PENDING;
setLastError(ERROR_IO_PENDING);
return FALSE;
}
}
@@ -854,11 +854,11 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
NTSTATUS completionStatus = STATUS_SUCCESS;
if (io.unixError != 0) {
completionStatus = wibo::statusFromErrno(io.unixError);
wibo::lastError = wibo::winErrorFromErrno(io.unixError);
setLastError(wibo::winErrorFromErrno(io.unixError));
} else if (io.reachedEnd && io.bytesTransferred == 0) {
if (file->isPipe) {
completionStatus = STATUS_PIPE_BROKEN;
wibo::lastError = ERROR_BROKEN_PIPE;
setLastError(ERROR_BROKEN_PIPE);
detail::signalOverlappedEvent(file.get(), lpOverlapped, completionStatus, 0);
DEBUG_LOG("-> ERROR_BROKEN_PIPE\n");
return FALSE;
@@ -872,7 +872,7 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
detail::signalOverlappedEvent(file.get(), lpOverlapped, completionStatus, io.bytesTransferred);
DEBUG_LOG("-> %u bytes read, error %d\n", io.bytesTransferred, io.unixError == 0 ? 0 : wibo::lastError);
DEBUG_LOG("-> %u bytes read, error %d\n", io.bytesTransferred, io.unixError == 0 ? 0 : getLastError());
return io.unixError == 0;
}
@@ -882,7 +882,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
HOST_CONTEXT_GUARD();
(void)hTemplateFile;
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
@@ -897,7 +897,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
HANDLE pipeHandle = INVALID_HANDLE_VALUE;
if (kernel32::tryCreateFileNamedPipeA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, pipeHandle)) {
DEBUG_LOG("CreateFileA(pipe=%s) -> %p (err=%u)\n", lpFileName, pipeHandle, wibo::lastError);
DEBUG_LOG("CreateFileA(pipe=%s) -> %p (err=%u)\n", lpFileName, pipeHandle, getLastError());
return pipeHandle;
}
@@ -920,12 +920,12 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
bool isDirectory = pathExists && status.type() == std::filesystem::file_type::directory;
if ((fileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 && !isDirectory) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG("-> ERROR_INVALID_PARAMETER (ENOTDIR)\n");
return INVALID_HANDLE_VALUE;
}
if (isDirectory && (!backupSemantics || deleteOnClose /* not currently implemented for dir */)) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED (EISDIR)\n");
return INVALID_HANDLE_VALUE;
}
@@ -940,7 +940,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
case CREATE_NEW:
allowCreate = true;
if (pathExists) {
wibo::lastError = ERROR_FILE_EXISTS;
setLastError(ERROR_FILE_EXISTS);
DEBUG_LOG("-> ERROR_FILE_EXISTS (EEXIST)");
return INVALID_HANDLE_VALUE;
}
@@ -948,7 +948,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
case CREATE_ALWAYS:
allowCreate = true;
if (isDirectory) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED (EISDIR)");
return INVALID_HANDLE_VALUE;
}
@@ -958,26 +958,26 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
if (!pathExists) {
allowCreate = true;
} else if (isDirectory) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED (EISDIR)");
return INVALID_HANDLE_VALUE;
}
break;
case OPEN_EXISTING:
if (!pathExists) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
DEBUG_LOG("-> ERROR_FILE_NOT_FOUND (ENOENT)");
return INVALID_HANDLE_VALUE;
}
break;
case TRUNCATE_EXISTING:
if (!pathExists) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
DEBUG_LOG("-> ERROR_FILE_NOT_FOUND (ENOENT)");
return INVALID_HANDLE_VALUE;
}
if (isDirectory) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED (EISDIR)");
return INVALID_HANDLE_VALUE;
}
@@ -995,7 +995,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
auto normalized =
wibo::access::normalizeDesiredAccess(dwDesiredAccess, genericMapping, supportedMask, SYNCHRONIZE, defaultMask);
if (normalized.deniedMask != 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED: denied mask 0x%x\n", normalized.deniedMask);
return INVALID_HANDLE_VALUE;
}
@@ -1007,17 +1007,17 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
bool appendOnly = appendRequested && !containsAny(normalized.grantedMask, FILE_WRITE_DATA);
#ifdef CHECK_ACCESS
if (allowCreate && !containsAny(normalized.grantedMask, FILE_WRITE_DATA | FILE_APPEND_DATA)) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED: FILE_WRITE_DATA | FILE_APPEND_DATA required for creation");
return INVALID_HANDLE_VALUE;
}
if (truncateExisting && !containsAny(normalized.grantedMask, FILE_WRITE_DATA)) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED: FILE_WRITE_DATA required for truncation");
return INVALID_HANDLE_VALUE;
}
if (deleteOnClose && !containsAny(normalized.grantedMask, DELETE)) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("-> ERROR_ACCESS_DENIED: DELETE required for delete-on-close");
return INVALID_HANDLE_VALUE;
}
@@ -1096,7 +1096,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
if ((dwCreationDisposition == OPEN_ALWAYS && existedBefore) ||
(dwCreationDisposition == CREATE_ALWAYS && existedBefore)) {
wibo::lastError = ERROR_ALREADY_EXISTS;
setLastError(ERROR_ALREADY_EXISTS);
}
DEBUG_LOG("-> %p (createdNew=%d, truncate=%d)\n", handle, createdNew ? 1 : 0, truncateExisting ? 1 : 0);
@@ -1109,7 +1109,7 @@ HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
HOST_CONTEXT_GUARD();
DEBUG_LOG("CreateFileW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
std::string lpFileNameA = wideStringToString(lpFileName);
@@ -1120,7 +1120,7 @@ HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) {
HOST_CONTEXT_GUARD();
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG("DeleteFileA(NULL) -> ERROR_INVALID_PARAMETER\n");
return FALSE;
}
@@ -1137,7 +1137,7 @@ BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("DeleteFileW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string name = wideStringToString(lpFileName);
@@ -1149,23 +1149,23 @@ BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) {
DEBUG_LOG("MoveFileA(%s, %s)\n", lpExistingFileName ? lpExistingFileName : "(null)",
lpNewFileName ? lpNewFileName : "(null)");
if (!lpExistingFileName || !lpNewFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto fromPath = files::pathFromWindows(lpExistingFileName);
auto toPath = files::pathFromWindows(lpNewFileName);
std::error_code ec;
if (std::filesystem::exists(toPath, ec)) {
wibo::lastError = ERROR_ALREADY_EXISTS;
setLastError(ERROR_ALREADY_EXISTS);
return FALSE;
}
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastError(wibo::winErrorFromErrno(ec.value()));
return FALSE;
}
std::filesystem::rename(fromPath, toPath, ec);
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastError(wibo::winErrorFromErrno(ec.value()));
return FALSE;
}
return TRUE;
@@ -1175,7 +1175,7 @@ BOOL WIN_FUNC MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("MoveFileW -> ");
if (!lpExistingFileName || !lpNewFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string from = wideStringToString(lpExistingFileName);
@@ -1188,13 +1188,13 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan
DEBUG_LOG("SetFilePointer(%p, %ld, %p, %u)\n", hFile, static_cast<long>(lDistanceToMove), lpDistanceToMoveHigh,
dwMoveMethod);
if (hFile == nullptr) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return INVALID_SET_FILE_POINTER;
}
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return INVALID_SET_FILE_POINTER;
}
// TODO access check
@@ -1210,9 +1210,9 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan
}
if (position < 0) {
if (errno == EINVAL) {
wibo::lastError = ERROR_NEGATIVE_SEEK;
setLastError(ERROR_NEGATIVE_SEEK);
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
}
return INVALID_SET_FILE_POINTER;
}
@@ -1227,13 +1227,13 @@ BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLA
DWORD dwMoveMethod) {
HOST_CONTEXT_GUARD();
if (hFile == nullptr) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
// TODO access check
@@ -1249,18 +1249,18 @@ BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLA
}
if (position < 0) {
if (errno == EINVAL) {
wibo::lastError = ERROR_NEGATIVE_SEEK;
setLastError(ERROR_NEGATIVE_SEEK);
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
}
return INVALID_SET_FILE_POINTER;
}
file->filePos = position;
if (position < 0) {
if (errno == EINVAL) {
wibo::lastError = ERROR_NEGATIVE_SEEK;
setLastError(ERROR_NEGATIVE_SEEK);
} else {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
}
return FALSE;
}
@@ -1276,7 +1276,7 @@ BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) {
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
// TODO access check
@@ -1296,7 +1296,7 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri
HOST_CONTEXT_GUARD();
(void)lpSecurityAttributes;
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string path = files::pathFromWindows(lpPathName);
@@ -1311,7 +1311,7 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri
BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
HOST_CONTEXT_GUARD();
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::string path = files::pathFromWindows(lpPathName);
@@ -1327,7 +1327,7 @@ BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
HOST_CONTEXT_GUARD();
(void)dwFileAttributes;
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
DEBUG_LOG("STUB: SetFileAttributesA(%s, %u)\n", lpFileName, dwFileAttributes);
@@ -1340,7 +1340,7 @@ DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
// TODO access check
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
DEBUG_LOG("-> INVALID_FILE_SIZE (ERROR_INVALID_HANDLE)\n");
return INVALID_FILE_SIZE;
}
@@ -1367,12 +1367,12 @@ BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lp
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
#ifdef CHECK_ACCESS
if ((meta.grantedAccess & FILE_READ_ATTRIBUTES) == 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
#endif
@@ -1396,7 +1396,7 @@ BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lp
};
if (!assignFileTime(lpCreationTime, changeTimespec(st)) || !assignFileTime(lpLastAccessTime, accessTimespec(st)) ||
!assignFileTime(lpLastWriteTime, modifyTimespec(st))) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
return TRUE;
@@ -1409,12 +1409,12 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
#ifdef CHECK_ACCESS
if ((meta.grantedAccess & FILE_WRITE_ATTRIBUTES) == 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
#endif
@@ -1436,7 +1436,7 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
uint32_t hundreds = 0;
if (!fileTimeToUnixParts(*lpLastAccessTime, seconds, hundreds) ||
!unixPartsToTimespec(seconds, hundreds, accessSpec)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
@@ -1445,7 +1445,7 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
uint32_t hundreds = 0;
if (!fileTimeToUnixParts(*lpLastWriteTime, seconds, hundreds) ||
!unixPartsToTimespec(seconds, hundreds, writeSpec)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
@@ -1476,13 +1476,13 @@ BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMAT
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetFileInformationByHandle(%p, %p)\n", hFile, lpFileInformation);
if (!lpFileInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
// TODO access check
@@ -1515,7 +1515,7 @@ DWORD WIN_FUNC GetFileType(HANDLE hFile) {
DEBUG_LOG("GetFileType(%p) ", hFile);
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
DEBUG_LOG("-> ERROR_INVALID_HANDLE\n");
return FILE_TYPE_UNKNOWN;
}
@@ -1548,7 +1548,7 @@ DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lp
}
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -1563,17 +1563,17 @@ DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lp
const auto required = static_cast<DWORD>(pathLen + 1);
if (nBufferLength == 0) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nBufferLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
@@ -1600,7 +1600,7 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR
}
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -1617,17 +1617,17 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR
const auto required = static_cast<DWORD>(wideLen);
if (nBufferLength == 0) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nBufferLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
@@ -1648,7 +1648,7 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetShortPathNameA(%s)\n", lpszLongPath ? lpszLongPath : "(null)");
if (!lpszLongPath || !lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -1656,7 +1656,7 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
std::string absStr = files::pathToWindows(absPath);
DWORD required = static_cast<DWORD>(absStr.length() + 1);
if (cchBuffer < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
@@ -1667,7 +1667,7 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer) {
HOST_CONTEXT_GUARD();
if (!lpszLongPath || !lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string longPath = wideStringToString(lpszLongPath);
@@ -1678,7 +1678,7 @@ DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWO
size_t len = wstrlen(absStrW.data());
DWORD required = static_cast<DWORD>(len + 1);
if (cchBuffer < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
wstrncpy(lpszShortPath, absStrW.data(), len + 1);
@@ -1690,11 +1690,11 @@ UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uU
DEBUG_LOG("GetTempFileNameA(%s, %s, %u)\n", lpPathName ? lpPathName : "(null)",
lpPrefixString ? lpPrefixString : "(null)", uUnique);
if (!lpPathName || !lpPrefixString || !lpTempFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (strlen(lpPathName) > MAX_PATH - 14) {
wibo::lastError = ERROR_BUFFER_OVERFLOW;
setLastError(ERROR_BUFFER_OVERFLOW);
return 0;
}
char uniqueStr[20];
@@ -1732,7 +1732,7 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
DEBUG_LOG("GetTempPathA(%u, %p)\n", nBufferLength, lpBuffer);
if (nBufferLength == 0 || lpBuffer == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
return 0;
}
@@ -1743,7 +1743,7 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
}
size_t len = strlen(path);
if (len + 1 > nBufferLength) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
DEBUG_LOG(" -> ERROR_INSUFFICIENT_BUFFER\n");
return static_cast<DWORD>(len + 1);
}
@@ -1758,12 +1758,12 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
HOST_CONTEXT_GUARD();
DEBUG_LOG("FindFirstFileA(%s, %p)", lpFileName ? lpFileName : "(null)", lpFindFileData);
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
return INVALID_HANDLE_VALUE;
}
if (!lpFileName) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
setLastError(ERROR_PATH_NOT_FOUND);
DEBUG_LOG(" -> ERROR_PATH_NOT_FOUND\n");
return INVALID_HANDLE_VALUE;
}
@@ -1777,12 +1777,12 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
HOST_CONTEXT_GUARD();
DEBUG_LOG("FindFirstFileW(%p, %p)", lpFileName, lpFindFileData);
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
return INVALID_HANDLE_VALUE;
}
if (!lpFileName) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
setLastError(ERROR_PATH_NOT_FOUND);
DEBUG_LOG(" -> ERROR_PATH_NOT_FOUND\n");
return INVALID_HANDLE_VALUE;
}
@@ -1800,32 +1800,32 @@ HANDLE WIN_FUNC FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLeve
lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
if (!lpFindFileData) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if (!lpFileName) {
DEBUG_LOG(" -> ERROR_PATH_NOT_FOUND\n");
wibo::lastError = ERROR_PATH_NOT_FOUND;
setLastError(ERROR_PATH_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
if (fInfoLevelId != FindExInfoStandard) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if (fSearchOp != FindExSearchNameMatch) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if (lpSearchFilter) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if (dwAdditionalFlags != 0) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
@@ -1838,7 +1838,7 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
DEBUG_LOG("FindNextFileA(%p, %p)\n", hFindFile, lpFindFileData);
if (!lpFindFileData) {
DEBUG_LOG(" -> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -1846,12 +1846,12 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
auto *state = lookupFindHandleLocked(hFindFile);
if (!state) {
DEBUG_LOG(" -> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (state->singleResult || state->nextIndex >= state->entries.size()) {
DEBUG_LOG(" -> ERROR_NO_MORE_FILES\n");
wibo::lastError = ERROR_NO_MORE_FILES;
setLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
populateFindData(state->entries[state->nextIndex++], *lpFindFileData);
@@ -1862,7 +1862,7 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
HOST_CONTEXT_GUARD();
DEBUG_LOG("FindNextFileW(%p, %p)\n", hFindFile, lpFindFileData);
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -1870,12 +1870,12 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
auto *state = lookupFindHandleLocked(hFindFile);
if (!state) {
DEBUG_LOG(" -> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (state->singleResult || state->nextIndex >= state->entries.size()) {
DEBUG_LOG(" -> ERROR_NO_MORE_FILES\n");
wibo::lastError = ERROR_NO_MORE_FILES;
setLastError(ERROR_NO_MORE_FILES);
return FALSE;
}
populateFindData(state->entries[state->nextIndex++], *lpFindFileData);
@@ -1887,14 +1887,14 @@ BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
DEBUG_LOG("FindClose(%p)\n", hFindFile);
if (hFindFile == nullptr) {
DEBUG_LOG(" -> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
auto owned = detachFindHandle(hFindFile);
if (!owned) {
DEBUG_LOG(" -> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;

8
dll/kernel32/handleapi.cpp
View File

@@ -18,7 +18,7 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
(void)dwDesiredAccess;
(void)dwOptions;
if (!lpTargetHandle) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -33,7 +33,7 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
if (!validateProcessHandle(hSourceProcessHandle) || !validateProcessHandle(hTargetProcessHandle)) {
DEBUG_LOG("DuplicateHandle: unsupported process handle combination (source=%p target=%p)\n",
hSourceProcessHandle, hTargetProcessHandle);
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
@@ -53,7 +53,7 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
}
if (!handles.duplicateTo(hSourceHandle, handles, *lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions)) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;
@@ -63,7 +63,7 @@ BOOL WIN_FUNC CloseHandle(HANDLE hObject) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("CloseHandle(%p)\n", hObject);
if (!wibo::handles().release(hObject)) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;

42
dll/kernel32/heapapi.cpp
View File

@@ -42,14 +42,14 @@ LPVOID heapAllocFromRecord(HeapObject *record, DWORD dwFlags, SIZE_T dwBytes) {
}
if ((record->createFlags | dwFlags) & HEAP_GENERATE_EXCEPTIONS) {
DEBUG_LOG("HeapAlloc: HEAP_GENERATE_EXCEPTIONS not supported\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
const bool zeroMemory = (dwFlags & HEAP_ZERO_MEMORY) != 0;
const SIZE_T requestSize = std::max<SIZE_T>(1, dwBytes);
void *mem = zeroMemory ? mi_heap_zalloc(record->heap, requestSize) : mi_heap_malloc(record->heap, requestSize);
if (!mem) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
kernel32::setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
if (isExecutableHeap(record)) {
@@ -79,13 +79,13 @@ HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaxim
HOST_CONTEXT_GUARD();
DEBUG_LOG("HeapCreate(%u, %zu, %zu)\n", flOptions, dwInitialSize, dwMaximumSize);
if (dwMaximumSize != 0 && dwInitialSize > dwMaximumSize) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
mi_heap_t *heap = mi_heap_new();
if (!heap) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
@@ -101,7 +101,7 @@ BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) {
DEBUG_LOG("HeapDestroy(%p)\n", hHeap);
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record || !record->isOwner() || record->isProcessHeap) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
mi_heap_destroy(record->heap);
@@ -124,13 +124,13 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI
HeapInformation, HeapInformationLength);
auto record = wibo::handles().getAs<HeapObject>(HeapHandle);
if (!record || !record->canAccess()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
switch (HeapInformationClass) {
case HeapCompatibilityInformation: {
if (!HeapInformation || HeapInformationLength < sizeof(ULONG)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
record->compatibility = *static_cast<ULONG *>(HeapInformation);
@@ -139,10 +139,10 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI
case HeapEnableTerminationOnCorruption:
return TRUE;
case HeapOptimizeResources:
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
setLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
default:
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
@@ -153,7 +153,7 @@ LPVOID WIN_FUNC HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) {
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record || !record->canAccess()) {
VERBOSE_LOG("-> NULL\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
void *mem = heapAllocFromRecord(record.get(), dwFlags, dwBytes);
@@ -167,7 +167,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record || !record->canAccess()) {
VERBOSE_LOG("-> NULL\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
if (lpMem == nullptr) {
@@ -177,12 +177,12 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
}
if (!mi_is_in_heap_region(lpMem)) {
VERBOSE_LOG("-> NULL (not owned)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
if ((record->createFlags | dwFlags) & HEAP_GENERATE_EXCEPTIONS) {
VERBOSE_LOG("-> NULL (exceptions unsupported)\n");
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return nullptr;
}
const bool inplaceOnly = (dwFlags & HEAP_REALLOC_IN_PLACE_ONLY) != 0;
@@ -194,7 +194,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
return nullptr;
}
VERBOSE_LOG("-> NULL (zero size with in-place flag)\n");
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
@@ -203,7 +203,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
if (inplaceOnly || requestSize <= oldSize) {
if (requestSize > oldSize) {
VERBOSE_LOG("-> NULL (cannot grow in place)\n");
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
VERBOSE_LOG("-> %p (in-place)\n", lpMem);
@@ -212,7 +212,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
void *ret = mi_heap_realloc(record->heap, lpMem, requestSize);
if (!ret) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
if (zeroMemory && requestSize > oldSize) {
@@ -236,17 +236,17 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record || !record->canAccess()) {
VERBOSE_LOG("-> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return static_cast<SIZE_T>(-1);
}
if (!lpMem) {
VERBOSE_LOG("-> ERROR_INVALID_PARAMETER\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return static_cast<SIZE_T>(-1);
}
if (!mi_is_in_heap_region(lpMem)) {
VERBOSE_LOG("-> ERROR_INVALID_PARAMETER (not owned)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return static_cast<SIZE_T>(-1);
}
size_t size = mi_usable_size(lpMem);
@@ -263,12 +263,12 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record || !record->canAccess()) {
VERBOSE_LOG("-> ERROR_INVALID_HANDLE\n");
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (!mi_is_in_heap_region(lpMem)) {
VERBOSE_LOG("-> ERROR_INVALID_PARAMETER (not owned)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
mi_free(lpMem);

3
dll/kernel32/internal.h
View File

@@ -176,6 +176,9 @@ void tryMarkExecutable(void *mem);
void setLastErrorFromErrno();
[[noreturn]] void exitInternal(DWORD exitCode);
DWORD getLastError();
void setLastError(DWORD error);
} // namespace kernel32
namespace detail {

8
dll/kernel32/ioapiset.cpp
View File

@@ -15,7 +15,7 @@ BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWO
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetOverlappedResult(%p, %p, %p, %d)\n", hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait);
if (!lpOverlapped) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -26,14 +26,14 @@ BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWO
std::unique_lock lk(file->m);
file->overlappedCv.wait(lk, [&] { return lpOverlapped->Internal != STATUS_PENDING; });
} else {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
}
const auto status = static_cast<NTSTATUS>(lpOverlapped->Internal);
if (status == STATUS_PENDING) {
wibo::lastError = ERROR_IO_INCOMPLETE;
setLastError(ERROR_IO_INCOMPLETE);
return FALSE;
}
@@ -45,7 +45,7 @@ BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWO
if (error == ERROR_SUCCESS) {
return TRUE;
}
wibo::lastError = error;
setLastError(error);
return FALSE;
}

44
dll/kernel32/libloaderapi.cpp
View File

@@ -18,7 +18,7 @@ HRSRC findResourceInternal(HMODULE hModule, const wibo::ResourceIdentifier &type
std::optional<uint16_t> language) {
auto *exe = wibo::executableFromModule(hModule);
if (!exe) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return nullptr;
}
wibo::ResourceLocation loc;
@@ -36,16 +36,16 @@ BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("DisableThreadLibraryCalls(%p)\n", hLibModule);
if (!hLibModule) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
wibo::ModuleInfo *info = wibo::moduleInfoFromHandle(hLibModule);
if (!info) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (!wibo::disableThreadNotifications(info)) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
return TRUE;
@@ -56,7 +56,7 @@ HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) {
DEBUG_LOG("GetModuleHandleA(%s)\n", lpModuleName);
const auto *module = wibo::findLoadedModule(lpModuleName);
if (!module) {
wibo::lastError = ERROR_MOD_NOT_FOUND;
setLastError(ERROR_MOD_NOT_FOUND);
return nullptr;
}
return module->handle;
@@ -76,12 +76,12 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetModuleFileNameA(%p, %p, %u)\n", hModule, lpFilename, nSize);
if (!lpFilename) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
auto *info = wibo::moduleInfoFromHandle(hModule);
if (!info) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string path;
@@ -92,7 +92,7 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
}
DEBUG_LOG("-> %s\n", path.c_str());
if (nSize == 0) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
const size_t len = path.size();
@@ -102,7 +102,7 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
lpFilename[copyLen] = '\0';
}
if (copyLen < len) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return nSize;
}
return static_cast<DWORD>(copyLen);
@@ -112,12 +112,12 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetModuleFileNameW(%p, %s, %u)\n", hModule, wideStringToString(lpFilename).c_str(), nSize);
if (!lpFilename) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
auto *info = wibo::moduleInfoFromHandle(hModule);
if (!info) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string path;
@@ -127,7 +127,7 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
path = info->originalName;
}
if (nSize == 0) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
auto wide = stringToWideString(path.c_str());
@@ -143,7 +143,7 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
lpFilename[copyLen] = 0;
}
if (copyLen < len) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return nSize;
}
return static_cast<DWORD>(copyLen);
@@ -185,17 +185,17 @@ HGLOBAL WIN_FUNC LoadResource(HMODULE hModule, HRSRC hResInfo) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("LoadResource %p %p\n", hModule, hResInfo);
if (!hResInfo) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return nullptr;
}
auto *exe = wibo::executableFromModule(hModule);
if (!exe || !exe->rsrcBase) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return nullptr;
}
const auto *entry = reinterpret_cast<const wibo::ImageResourceDataEntry *>(hResInfo);
if (!wibo::resourceEntryBelongsToExecutable(*exe, entry)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
return const_cast<void *>(exe->fromRVA<const void>(entry->offsetToData));
@@ -211,17 +211,17 @@ DWORD WIN_FUNC SizeofResource(HMODULE hModule, HRSRC hResInfo) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("SizeofResource(%p, %p)\n", hModule, hResInfo);
if (!hResInfo) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return 0;
}
auto *exe = wibo::executableFromModule(hModule);
if (!exe || !exe->rsrcBase) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return 0;
}
const auto *entry = reinterpret_cast<const wibo::ImageResourceDataEntry *>(hResInfo);
if (!wibo::resourceEntryBelongsToExecutable(*exe, entry)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
return entry->size;
@@ -262,7 +262,7 @@ BOOL WIN_FUNC FreeLibrary(HMODULE hLibModule) {
DEBUG_LOG("FreeLibrary(%p)\n", hLibModule);
auto *info = wibo::moduleInfoFromHandle(hLibModule);
if (!info) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
wibo::freeModule(info);
@@ -275,7 +275,7 @@ FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
const auto info = wibo::moduleInfoFromHandle(hModule);
if (!info) {
DEBUG_LOG("GetProcAddress(%p) -> ERROR_INVALID_HANDLE\n", hModule);
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
const auto proc = reinterpret_cast<uintptr_t>(lpProcName);
@@ -288,7 +288,7 @@ FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
}
DEBUG_LOG("-> %p\n", result);
if (!result) {
wibo::lastError = ERROR_PROC_NOT_FOUND;
setLastError(ERROR_PROC_NOT_FOUND);
}
return result;
}

126
dll/kernel32/memoryapi.cpp
View File

@@ -473,7 +473,7 @@ HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap
uint64_t size = (static_cast<uint64_t>(dwMaximumSizeHigh) << 32) | dwMaximumSizeLow;
if (flProtect != PAGE_READONLY && flProtect != PAGE_READWRITE && flProtect != PAGE_WRITECOPY) {
DEBUG_LOG("CreateFileMappingA: unsupported protection 0x%x\n", flProtect);
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
@@ -484,14 +484,14 @@ HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap
mapping->anonymous = true;
mapping->fd = -1;
if (size == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
mapping->maxSize = size;
} else {
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
int dupFd = fcntl(file->fd, F_DUPFD_CLOEXEC, 0);
@@ -525,32 +525,32 @@ HANDLE WIN_FUNC CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap
static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredAccess, uint64_t offset,
SIZE_T dwNumberOfBytesToMap, LPVOID baseAddress) {
if (!mapping) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
if (mapping->closed) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
if (mapping->anonymous && offset != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
size_t maxSize = mapping->maxSize;
uint64_t length = static_cast<uint64_t>(dwNumberOfBytesToMap);
if (length == 0) {
if (maxSize == 0 || offset > maxSize) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
length = maxSize - offset;
}
if (length == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
if (maxSize != 0 && offset + length > maxSize) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
@@ -568,7 +568,7 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
}
} else {
if (wantWrite && !wantCopy) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
return nullptr;
}
if (wantCopy) {
@@ -585,12 +585,12 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
size_t offsetDelta = static_cast<size_t>(offset - static_cast<uint64_t>(alignedOffset));
uint64_t requestedLength = length + offsetDelta;
if (requestedLength < length) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
size_t mapLength = static_cast<size_t>(requestedLength);
if (static_cast<uint64_t>(mapLength) != requestedLength) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
@@ -600,16 +600,16 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
if (baseAddress) {
uintptr_t baseAddr = reinterpret_cast<uintptr_t>(baseAddress);
if (baseAddr == 0 || (baseAddr % kVirtualAllocationGranularity) != 0) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
if (offsetDelta > baseAddr) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
uintptr_t mapBaseAddr = baseAddr - offsetDelta;
if ((mapBaseAddr & (pageSize - 1)) != 0) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
requestedBase = reinterpret_cast<void *>(mapBaseAddr);
@@ -625,16 +625,16 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
if (mapBase == MAP_FAILED) {
int err = errno;
if (baseAddress && (err == ENOMEM || err == EEXIST || err == EINVAL || err == EPERM)) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
} else {
wibo::lastError = wibo::winErrorFromErrno(err);
setLastError(wibo::winErrorFromErrno(err));
}
return nullptr;
}
void *viewPtr = static_cast<uint8_t *>(mapBase) + offsetDelta;
if (baseAddress && viewPtr != baseAddress) {
munmap(mapBase, mapLength);
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
uintptr_t viewLength = static_cast<uintptr_t>(length);
@@ -667,7 +667,7 @@ LPVOID WIN_FUNC MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess,
auto mapping = wibo::handles().getAs<MappingObject>(hFileMappingObject);
if (!mapping) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
uint64_t offset = (static_cast<uint64_t>(dwFileOffsetHigh) << 32) | dwFileOffsetLow;
@@ -682,7 +682,7 @@ LPVOID WIN_FUNC MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess
auto mapping = wibo::handles().getAs<MappingObject>(hFileMappingObject);
if (!mapping) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
uint64_t offset = (static_cast<uint64_t>(dwFileOffsetHigh) << 32) | dwFileOffsetLow;
@@ -695,7 +695,7 @@ BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) {
std::unique_lock lk(g_viewInfoMutex);
auto it = g_viewInfo.find(reinterpret_cast<uintptr_t>(lpBaseAddress));
if (it == g_viewInfo.end()) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
void *base = reinterpret_cast<void *>(it->second.allocationBase);
@@ -713,7 +713,7 @@ BOOL WIN_FUNC FlushViewOfFile(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlu
DEBUG_LOG("FlushViewOfFile(%p, %zu)\n", lpBaseAddress, dwNumberOfBytesToFlush);
if (!lpBaseAddress) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -727,13 +727,13 @@ BOOL WIN_FUNC FlushViewOfFile(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlu
std::lock_guard guard(g_viewInfoMutex);
auto it = g_viewInfo.upper_bound(address);
if (it == g_viewInfo.begin()) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
--it;
const auto &view = it->second;
if (address < view.viewBase || address >= view.viewBase + view.viewLength) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
viewBase = view.viewBase;
@@ -766,7 +766,7 @@ BOOL WIN_FUNC FlushViewOfFile(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlu
alignedEnd = mappingEnd;
}
if (alignedEnd < alignedStart) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -776,7 +776,7 @@ BOOL WIN_FUNC FlushViewOfFile(LPCVOID lpBaseAddress, SIZE_T dwNumberOfBytesToFlu
}
if (msync(reinterpret_cast<void *>(alignedStart), length, MS_SYNC) != 0) {
wibo::lastError = wibo::winErrorFromErrno(errno);
setLastError(wibo::winErrorFromErrno(errno));
return FALSE;
}
@@ -788,14 +788,14 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
DEBUG_LOG("VirtualAlloc(%p, %zu, %u, %u)\n", lpAddress, dwSize, flAllocationType, flProtect);
if (dwSize == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
DWORD unsupportedFlags = flAllocationType & (MEM_WRITE_WATCH | MEM_PHYSICAL | MEM_LARGE_PAGES | MEM_RESET_UNDO);
if (unsupportedFlags != 0) {
DEBUG_LOG("VirtualAlloc unsupported flags: 0x%x\n", unsupportedFlags);
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return nullptr;
}
@@ -809,17 +809,17 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
if (reset) {
if (reserve || commit) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
if (!lpAddress) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
const size_t pageSize = systemPageSize();
uintptr_t request = reinterpret_cast<uintptr_t>(lpAddress);
if (addOverflows(request, static_cast<size_t>(dwSize))) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
uintptr_t start = alignDown(request, pageSize);
@@ -828,7 +828,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
std::unique_lock lk(g_virtualAllocMutex);
VirtualAllocation *region = lookupRegion(start);
if (!region || !rangeWithinRegion(*region, start, length)) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
#ifdef MADV_FREE
@@ -844,7 +844,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
}
if (!reserve && !commit) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
@@ -859,24 +859,24 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
base = alignDown(request, kVirtualAllocationGranularity);
size_t offset = static_cast<size_t>(request - base);
if (addOverflows(offset, static_cast<size_t>(dwSize))) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
size_t span = static_cast<size_t>(dwSize) + offset;
uintptr_t alignedSpan = alignUp(span, pageSize);
if (alignedSpan == std::numeric_limits<uintptr_t>::max()) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
length = static_cast<size_t>(alignedSpan);
if (length == 0 || rangeOverlapsLocked(base, length)) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
} else {
uintptr_t aligned = alignUp(static_cast<uintptr_t>(dwSize), pageSize);
if (aligned == std::numeric_limits<uintptr_t>::max() || aligned == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
length = static_cast<size_t>(aligned);
@@ -903,7 +903,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
}
if (reinterpret_cast<uintptr_t>(result) >= 0x80000000) {
munmap(result, length);
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
uintptr_t actualBase = reinterpret_cast<uintptr_t>(result);
@@ -918,19 +918,19 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
uintptr_t request = reinterpret_cast<uintptr_t>(lpAddress);
if (addOverflows(request, static_cast<size_t>(dwSize))) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
uintptr_t start = alignDown(request, pageSize);
uintptr_t end = alignUp(request + static_cast<uintptr_t>(dwSize), pageSize);
size_t length = static_cast<size_t>(end - start);
if (length == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
VirtualAllocation *region = lookupRegion(start);
if (!region || !rangeWithinRegion(*region, start, length)) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
const size_t pageCount = length / pageSize;
@@ -939,7 +939,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
for (size_t i = 0; i < pageCount; ++i) {
size_t pageIndex = ((start - region->base) / pageSize) + i;
if (pageIndex >= region->pageProtect.size()) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return nullptr;
}
if (region->pageProtect[pageIndex] != 0) {
@@ -974,19 +974,19 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("VirtualFree(%p, %zu, %u)\n", lpAddress, dwSize, dwFreeType);
if (!lpAddress) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return FALSE;
}
if ((dwFreeType & (MEM_COALESCE_PLACEHOLDERS | MEM_PRESERVE_PLACEHOLDER)) != 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}
const bool release = (dwFreeType & MEM_RELEASE) != 0;
const bool decommit = (dwFreeType & MEM_DECOMMIT) != 0;
if (release == decommit) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -999,14 +999,14 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
if (exact == g_virtualAllocations.end()) {
auto containing = findRegionIterator(base);
if (dwSize != 0 && containing != g_virtualAllocations.end()) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
} else {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
}
return FALSE;
}
if (dwSize != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
size_t length = exact->second.size;
@@ -1022,7 +1022,7 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
uintptr_t request = reinterpret_cast<uintptr_t>(lpAddress);
auto regionIt = findRegionIterator(request);
if (regionIt == g_virtualAllocations.end()) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return FALSE;
}
VirtualAllocation &region = regionIt->second;
@@ -1030,25 +1030,25 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
uintptr_t end = 0;
if (dwSize == 0) {
if (request != region.base) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
start = region.base;
end = region.base + region.size;
} else {
if (addOverflows(request, static_cast<size_t>(dwSize))) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
end = alignUp(request + static_cast<uintptr_t>(dwSize), pageSize);
}
if (end <= start) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
size_t length = static_cast<size_t>(end - start);
if (!rangeWithinRegion(region, start, length)) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return FALSE;
}
void *result = mmap(reinterpret_cast<void *>(start), length, PROT_NONE,
@@ -1065,7 +1065,7 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
HOST_CONTEXT_GUARD();
DEBUG_LOG("VirtualProtect(%p, %zu, %u)\n", lpAddress, dwSize, flNewProtect);
if (!lpAddress || dwSize == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -1074,32 +1074,32 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
uintptr_t start = alignDown(request, pageSize);
uintptr_t end = alignUp(request + static_cast<uintptr_t>(dwSize), pageSize);
if (end <= start) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::unique_lock lk(g_virtualAllocMutex);
VirtualAllocation *region = lookupRegion(start);
if (!region || !rangeWithinRegion(*region, start, static_cast<size_t>(end - start))) {
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
return FALSE;
}
const size_t firstPage = (start - region->base) / pageSize;
const size_t pageCount = (end - start) / pageSize;
if (pageCount == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
DWORD previousProtect = region->pageProtect[firstPage];
if (previousProtect == 0) {
wibo::lastError = ERROR_NOACCESS;
setLastError(ERROR_NOACCESS);
return FALSE;
}
for (size_t i = 0; i < pageCount; ++i) {
if (region->pageProtect[firstPage + i] == 0) {
wibo::lastError = ERROR_NOACCESS;
setLastError(ERROR_NOACCESS);
return FALSE;
}
}
@@ -1124,7 +1124,7 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
HOST_CONTEXT_GUARD();
DEBUG_LOG("VirtualQuery(%p, %p, %zu)\n", lpAddress, lpBuffer, dwLength);
if (!lpBuffer || dwLength < sizeof(MEMORY_BASIC_INFORMATION)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG("-> ERROR_INVALID_PARAMETER\n");
return 0;
}
@@ -1134,7 +1134,7 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
uintptr_t request = lpAddress ? reinterpret_cast<uintptr_t>(lpAddress) : 0;
uintptr_t pageBase = alignDown(request, pageSize);
if (pageBase >= kProcessAddressLimit) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG("-> ERROR_INVALID_PARAMETER (beyond address space)\n");
return 0;
}
@@ -1153,7 +1153,7 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
return sizeof(MEMORY_BASIC_INFORMATION);
}
wibo::lastError = ERROR_INVALID_ADDRESS;
setLastError(ERROR_INVALID_ADDRESS);
DEBUG_LOG("-> ERROR_INVALID_ADDRESS\n");
return 0;
}
@@ -1164,7 +1164,7 @@ BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorking
DEBUG_LOG("GetProcessWorkingSetSize(%p, %p, %p)\n", hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize);
(void)hProcess;
if (!lpMinimumWorkingSetSize || !lpMaximumWorkingSetSize) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpMinimumWorkingSetSize = 32 * 1024 * 1024; // 32 MiB stub

44
dll/kernel32/namedpipeapi.cpp
View File

@@ -284,7 +284,7 @@ bool tryCreateFileNamedPipeA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
auto parsed = parsePipeName(lpFileName, parseError);
if (!parsed) {
if (parseError != ERROR_SUCCESS) {
wibo::lastError = parseError;
setLastError(parseError);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
@@ -293,7 +293,7 @@ bool tryCreateFileNamedPipeA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
auto state = wibo::g_namespace.getAs<NamedPipeState>(parsed->namespaceKey);
if (!state) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
@@ -301,14 +301,14 @@ bool tryCreateFileNamedPipeA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
DWORD acquireError = ERROR_SUCCESS;
auto instancePin = acquireConnectableInstance(state, dwDesiredAccess, acquireError);
if (!instancePin) {
wibo::lastError = acquireError;
setLastError(acquireError);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
int clientFd = instancePin->takeCompanion();
if (clientFd < 0) {
wibo::lastError = ERROR_PIPE_BUSY;
setLastError(ERROR_PIPE_BUSY);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
@@ -319,7 +319,7 @@ bool tryCreateFileNamedPipeA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
auto clientObj = make_pin<FileObject>(clientFd);
if (!clientObj) {
instancePin->restoreCompanion(clientFd);
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
outHandle = INVALID_HANDLE_VALUE;
return true;
}
@@ -352,7 +352,7 @@ BOOL WIN_FUNC CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRI
HOST_CONTEXT_GUARD();
DEBUG_LOG("CreatePipe(%p, %p, %p, %u)\n", hReadPipe, hWritePipe, lpPipeAttributes, nSize);
if (!hReadPipe || !hWritePipe) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*hReadPipe = nullptr;
@@ -393,20 +393,20 @@ HANDLE WIN_FUNC CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMo
DWORD parseError = ERROR_SUCCESS;
std::optional<ParsedPipeName> parsed = parsePipeName(lpName, parseError);
if (!parsed) {
wibo::lastError = (parseError == ERROR_SUCCESS) ? ERROR_INVALID_NAME : parseError;
setLastError((parseError == ERROR_SUCCESS) ? ERROR_INVALID_NAME : parseError);
return INVALID_HANDLE_VALUE;
}
constexpr DWORD kAllowedOpenFlags = PIPE_ACCESS_DUPLEX | WRITE_DAC | WRITE_OWNER | ACCESS_SYSTEM_SECURITY |
FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_OVERLAPPED;
if ((dwOpenMode & ~kAllowedOpenFlags) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
DWORD accessMode = dwOpenMode & PIPE_ACCESS_DUPLEX;
if (accessMode != PIPE_ACCESS_DUPLEX && accessMode != PIPE_ACCESS_INBOUND && accessMode != PIPE_ACCESS_OUTBOUND) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
@@ -417,11 +417,11 @@ HANDLE WIN_FUNC CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMo
constexpr DWORD kAllowedPipeModeFlags =
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_NOWAIT | PIPE_REJECT_REMOTE_CLIENTS;
if ((dwPipeMode & ~kAllowedPipeModeFlags) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
if ((dwPipeMode & PIPE_READMODE_MESSAGE) != 0 && (dwPipeMode & PIPE_TYPE_MESSAGE) == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
@@ -431,7 +431,7 @@ HANDLE WIN_FUNC CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMo
auto [state, isNewState] = wibo::g_namespace.getOrCreate(
parsed->namespaceKey, [&]() -> NamedPipeState * { return new NamedPipeState(parsed->key); });
if (!state) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return INVALID_HANDLE_VALUE;
}
@@ -439,7 +439,7 @@ HANDLE WIN_FUNC CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMo
DWORD reserveError = ERROR_SUCCESS;
if (!state->reserveInstance(accessMode, pipeType, nDefaultTimeOut, normalizedMaxInstances, firstInstanceFlag,
isNewState, reserveError)) {
wibo::lastError = reserveError;
setLastError(reserveError);
return INVALID_HANDLE_VALUE;
}
instanceReserved = true;
@@ -459,7 +459,7 @@ HANDLE WIN_FUNC CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMo
state->releaseInstance();
instanceReserved = false;
}
wibo::lastError = err;
setLastError(err);
return INVALID_HANDLE_VALUE;
};
@@ -532,35 +532,35 @@ BOOL WIN_FUNC ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped) {
auto pipe = wibo::handles().getAs<NamedPipeInstance>(hNamedPipe);
if (!pipe) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
const bool isOverlappedHandle = pipe->overlapped;
if (isOverlappedHandle && lpOverlapped == nullptr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::unique_lock lock(pipe->connectMutex);
if (pipe->clientConnected) {
wibo::lastError = ERROR_PIPE_CONNECTED;
setLastError(ERROR_PIPE_CONNECTED);
return FALSE;
}
if (pipe->companionFd < 0) {
wibo::lastError = ERROR_PIPE_BUSY;
setLastError(ERROR_PIPE_BUSY);
return FALSE;
}
if (pipe->connectPending) {
wibo::lastError = ERROR_PIPE_LISTENING;
setLastError(ERROR_PIPE_LISTENING);
return FALSE;
}
if ((pipe->pipeMode & PIPE_NOWAIT) != 0) {
wibo::lastError = ERROR_PIPE_LISTENING;
setLastError(ERROR_PIPE_LISTENING);
return FALSE;
}
@@ -571,7 +571,7 @@ BOOL WIN_FUNC ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped) {
lpOverlapped->InternalHigh = 0;
kernel32::detail::resetOverlappedEvent(lpOverlapped);
lock.unlock();
wibo::lastError = ERROR_IO_PENDING;
setLastError(ERROR_IO_PENDING);
return FALSE;
}
@@ -579,7 +579,7 @@ BOOL WIN_FUNC ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped) {
pipe->connectCv.wait(lock, [&]() { return pipe->clientConnected || pipe->companionFd < 0; });
pipe->connectPending = false;
if (!pipe->clientConnected) {
wibo::lastError = ERROR_NO_DATA;
setLastError(ERROR_NO_DATA);
return FALSE;
}
return TRUE;

24
dll/kernel32/processenv.cpp
View File

@@ -80,7 +80,7 @@ LPCH WIN_FUNC GetEnvironmentStrings() {
char *buffer = static_cast<char *>(mi_malloc(bufSize));
if (!buffer) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
char *ptr = buffer;
@@ -113,7 +113,7 @@ LPWCH WIN_FUNC GetEnvironmentStringsW() {
uint16_t *buffer = static_cast<uint16_t *>(mi_malloc(bufSizeW * sizeof(uint16_t)));
if (!buffer) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return nullptr;
}
uint16_t *ptr = buffer;
@@ -137,7 +137,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("FreeEnvironmentStringsA(%p)\n", penv);
if (!penv) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
free(penv);
@@ -148,7 +148,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("FreeEnvironmentStringsW(%p)\n", penv);
if (!penv) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
free(penv);
@@ -159,12 +159,12 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetEnvironmentVariableA(%s, %p, %u)\n", lpName ? lpName : "(null)", lpBuffer, nSize);
if (!lpName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
const char *rawValue = getenv(lpName);
if (!rawValue) {
wibo::lastError = ERROR_ENVVAR_NOT_FOUND;
setLastError(ERROR_ENVVAR_NOT_FOUND);
return 0;
}
std::string converted = convertEnvValueForWindows(lpName, rawValue);
@@ -174,7 +174,7 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz
return len + 1;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nSize <= len) {
@@ -189,12 +189,12 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS
std::string name = lpName ? wideStringToString(lpName) : std::string();
DEBUG_LOG("GetEnvironmentVariableW(%s, %p, %u)\n", name.c_str(), lpBuffer, nSize);
if (name.empty()) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
const char *rawValue = getenv(name.c_str());
if (!rawValue) {
wibo::lastError = ERROR_ENVVAR_NOT_FOUND;
setLastError(ERROR_ENVVAR_NOT_FOUND);
return 0;
}
std::string converted = convertEnvValueForWindows(name, rawValue);
@@ -205,7 +205,7 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS
return required;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nSize < required) {
@@ -219,7 +219,7 @@ BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetEnvironmentVariableA(%s, %s)\n", lpName ? lpName : "(null)", lpValue ? lpValue : "(null)");
if (!lpName || std::strchr(lpName, '=')) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
int rc = 0;
@@ -245,7 +245,7 @@ BOOL WIN_FUNC SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetEnvironmentVariableW -> ");
if (!lpName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
DEBUG_LOG("ERROR_INVALID_PARAMETER\n");
return FALSE;
}

64
dll/kernel32/processthreadsapi.cpp
View File

@@ -225,14 +225,14 @@ BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffini
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetProcessAffinityMask(%p, %p, %p)\n", hProcess, lpProcessAffinityMask, lpSystemAffinityMask);
if (!lpProcessAffinityMask || !lpSystemAffinityMask) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!isPseudoCurrentProcessHandle(hProcess)) {
auto obj = wibo::handles().getAs<ProcessObject>(hProcess);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return 0;
}
}
@@ -256,21 +256,21 @@ BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinit
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetProcessAffinityMask(%p, 0x%lx)\n", hProcess, static_cast<unsigned long>(dwProcessAffinityMask));
if (dwProcessAffinityMask == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!isPseudoCurrentProcessHandle(hProcess)) {
auto obj = wibo::handles().getAs<ProcessObject>(hProcess);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return 0;
}
}
DWORD_PTR systemMask = computeSystemAffinityMask();
if ((dwProcessAffinityMask & systemMask) == 0 || (dwProcessAffinityMask & ~systemMask) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -283,14 +283,14 @@ DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffin
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetThreadAffinityMask(%p, 0x%lx)\n", hThread, static_cast<unsigned long>(dwThreadAffinityMask));
if (dwThreadAffinityMask == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (!isPseudoCurrentThreadHandle(hThread)) {
auto obj = wibo::handles().getAs<ThreadObject>(hThread);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return 0;
}
}
@@ -301,7 +301,7 @@ DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffin
return 0;
}
if ((dwThreadAffinityMask & ~systemMask) != 0 || (dwThreadAffinityMask & processMask) == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -328,7 +328,7 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
}
auto process = wibo::handles().getAs<ProcessObject>(hProcess);
if (!process) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
std::lock_guard lk(process->m);
@@ -341,10 +341,10 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
switch (err) {
case ESRCH:
case EPERM:
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
break;
default:
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
break;
}
return FALSE;
@@ -358,7 +358,7 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetExitCodeProcess(%p, %p)\n", hProcess, lpExitCode);
if (!lpExitCode) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (isPseudoCurrentProcessHandle(hProcess)) {
@@ -367,7 +367,7 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
}
auto process = wibo::handles().getAs<ProcessObject>(hProcess);
if (!process) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
DWORD exitCode = STILL_ACTIVE;
@@ -384,10 +384,10 @@ DWORD WIN_FUNC TlsAlloc() {
VERBOSE_LOG("TlsAlloc()\n");
DWORD index = wibo::tls::reserveSlot();
if (index == wibo::tls::kInvalidTlsIndex) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
setLastError(ERROR_NOT_ENOUGH_MEMORY);
return TLS_OUT_OF_INDEXES;
}
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return index;
}
@@ -395,10 +395,10 @@ BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) {
HOST_CONTEXT_GUARD();
VERBOSE_LOG("TlsFree(%u)\n", dwTlsIndex);
if (!wibo::tls::releaseSlot(dwTlsIndex)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return TRUE;
}
@@ -406,11 +406,11 @@ LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) {
HOST_CONTEXT_GUARD();
VERBOSE_LOG("TlsGetValue(%u)\n", dwTlsIndex);
if (!wibo::tls::isSlotAllocated(dwTlsIndex)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
void *result = wibo::tls::getValue(dwTlsIndex);
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return result;
}
@@ -418,14 +418,14 @@ BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) {
HOST_CONTEXT_GUARD();
VERBOSE_LOG("TlsSetValue(%u, %p)\n", dwTlsIndex, lpTlsValue);
if (!wibo::tls::isSlotAllocated(dwTlsIndex)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!wibo::tls::setValue(dwTlsIndex, lpTlsValue)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return TRUE;
}
@@ -435,7 +435,7 @@ DWORD WIN_FUNC ResumeThread(HANDLE hThread) {
// TODO: behavior with current thread handle?
auto obj = wibo::handles().getAs<ThreadObject>(hThread);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return static_cast<DWORD>(-1);
}
DWORD previous = 0;
@@ -476,7 +476,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw
constexpr DWORD SUPPORTED_FLAGS = CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION;
if ((dwCreationFlags & ~SUPPORTED_FLAGS) != 0) {
DEBUG_LOG("CreateThread: unsupported creation flags 0x%x\n", dwCreationFlags);
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return nullptr;
}
@@ -504,7 +504,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw
// Clean up
delete startData;
detail::deref(obj.get());
wibo::lastError = wibo::winErrorFromErrno(rc);
setLastError(wibo::winErrorFromErrno(rc));
return INVALID_HANDLE_VALUE;
}
@@ -534,7 +534,7 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetExitCodeThread(%p, %p)\n", hThread, lpExitCode);
if (!lpExitCode) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (isPseudoCurrentThreadHandle(hThread)) {
@@ -543,7 +543,7 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
}
auto obj = wibo::handles().getAs<ThreadObject>(hThread);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
std::lock_guard lk(obj->m);
@@ -579,13 +579,13 @@ BOOL WIN_FUNC GetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime, FILETIME
DEBUG_LOG("GetThreadTimes(%p, %p, %p, %p, %p)\n", hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime);
if (!lpKernelTime || !lpUserTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!isPseudoCurrentThreadHandle(hThread)) {
DEBUG_LOG("GetThreadTimes: unsupported handle %p\n", hThread);
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
@@ -635,7 +635,7 @@ BOOL WIN_FUNC CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSE
} else {
std::vector<std::string> arguments = wibo::splitCommandLine(commandLine.c_str());
if (arguments.empty()) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
return FALSE;
}
application = arguments.front();
@@ -643,14 +643,14 @@ BOOL WIN_FUNC CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSE
auto resolved = wibo::resolveExecutable(application, useSearchPath);
if (!resolved) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
setLastError(ERROR_FILE_NOT_FOUND);
return FALSE;
}
Pin<ProcessObject> obj;
int spawnResult = wibo::spawnWithCommandLine(*resolved, commandLine, obj);
if (spawnResult != 0) {
wibo::lastError = (spawnResult == ENOENT) ? ERROR_FILE_NOT_FOUND : ERROR_ACCESS_DENIED;
setLastError((spawnResult == ENOENT) ? ERROR_FILE_NOT_FOUND : ERROR_ACCESS_DENIED);
return FALSE;
}

5
dll/kernel32/profileapi.cpp
View File

@@ -3,6 +3,7 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "internal.h"
namespace kernel32 {
@@ -10,7 +11,7 @@ BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) {
HOST_CONTEXT_GUARD();
VERBOSE_LOG("STUB: QueryPerformanceCounter(%p)\n", lpPerformanceCount);
if (!lpPerformanceCount) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpPerformanceCount = 0;
@@ -21,7 +22,7 @@ BOOL WIN_FUNC QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) {
HOST_CONTEXT_GUARD();
VERBOSE_LOG("STUB: QueryPerformanceFrequency(%p)\n", lpFrequency);
if (!lpFrequency) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpFrequency = 1;

7
dll/kernel32/stringapiset.cpp
View File

@@ -3,6 +3,7 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "internal.h"
#include "strutil.h"
#include <cstring>
@@ -78,7 +79,7 @@ BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWO
assert(dwInfoType == 1); // CT_CTYPE1
if (!lpSrcStr || !lpCharType) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -110,11 +111,11 @@ BOOL WIN_FUNC GetStringTypeA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int
(void)Locale;
if (!lpSrcStr || !lpCharType) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (dwInfoType != 1) {
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return FALSE;
}

50
dll/kernel32/synchapi.cpp
View File

@@ -157,11 +157,11 @@ HANDLE WIN_FUNC CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInit
});
if (!mu) {
// Name exists but isn't a mutex
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
HANDLE h = wibo::handles().alloc(std::move(mu), grantedAccess, handleFlags);
wibo::lastError = created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS;
setLastError(created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS);
return h;
}
@@ -179,7 +179,7 @@ BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) {
DEBUG_LOG("ReleaseMutex(%p)\n", hMutex);
auto mu = wibo::handles().getAs<MutexObject>(hMutex);
if (!mu) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
const pthread_t self = pthread_self();
@@ -187,7 +187,7 @@ BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) {
{
std::lock_guard lk(mu->m);
if (!mu->ownerValid || !pthread_equal(mu->owner, self) || mu->recursionCount == 0) {
wibo::lastError = ERROR_NOT_OWNER;
setLastError(ERROR_NOT_OWNER);
return FALSE;
}
if (--mu->recursionCount == 0) {
@@ -221,12 +221,12 @@ HANDLE WIN_FUNC CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManu
});
if (!ev) {
// Name exists but isn't an event
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
HANDLE h = wibo::handles().alloc(std::move(ev), grantedAccess, handleFlags);
DEBUG_LOG("-> %p (created=%d)\n", h, created ? 1 : 0);
wibo::lastError = created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS;
setLastError(created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS);
return h;
}
@@ -259,11 +259,11 @@ HANDLE WIN_FUNC CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LO
});
if (!sem) {
// Name exists but isn't an event
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return nullptr;
}
HANDLE h = wibo::handles().alloc(std::move(sem), granted, hflags);
wibo::lastError = created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS;
setLastError(created ? ERROR_SUCCESS : ERROR_ALREADY_EXISTS);
return h;
}
@@ -281,12 +281,12 @@ BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPr
HOST_CONTEXT_GUARD();
DEBUG_LOG("ReleaseSemaphore(%p, %ld, %p)\n", hSemaphore, lReleaseCount, lpPreviousCount);
if (lReleaseCount < 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
auto sem = wibo::handles().getAs<SemaphoreObject>(hSemaphore);
if (!sem) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
@@ -298,7 +298,7 @@ BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPr
prev = sem->count;
}
if (sem->count > sem->maxCount - lReleaseCount) {
wibo::lastError = ERROR_TOO_MANY_POSTS;
setLastError(ERROR_TOO_MANY_POSTS);
return FALSE;
}
sem->count += lReleaseCount;
@@ -323,7 +323,7 @@ BOOL WIN_FUNC SetEvent(HANDLE hEvent) {
DEBUG_LOG("SetEvent(%p)\n", hEvent);
auto ev = wibo::handles().getAs<EventObject>(hEvent);
if (!ev) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
ev->set();
@@ -335,7 +335,7 @@ BOOL WIN_FUNC ResetEvent(HANDLE hEvent) {
DEBUG_LOG("ResetEvent(%p)\n", hEvent);
auto ev = wibo::handles().getAs<EventObject>(hEvent);
if (!ev) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
ev->reset();
@@ -348,13 +348,13 @@ DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) {
HandleMeta meta{};
Pin<> obj = wibo::handles().get(hHandle, &meta);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
DEBUG_LOG("-> ERROR_INVALID_HANDLE\n");
return WAIT_FAILED;
}
#ifdef CHECK_ACCESS
if ((meta.grantedAccess & SYNCHRONIZE) == 0) {
wibo::lastError = ERROR_ACCESS_DENIED;
setLastError(ERROR_ACCESS_DENIED);
DEBUG_LOG("!!! DENIED: 0x%x\n", meta.grantedAccess);
return WAIT_FAILED;
}
@@ -443,7 +443,7 @@ DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) {
return ok ? WAIT_OBJECT_0 : WAIT_TIMEOUT;
}
default:
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return WAIT_FAILED;
}
}
@@ -454,7 +454,7 @@ DWORD WIN_FUNC WaitForMultipleObjects(DWORD nCount, const HANDLE *lpHandles, BOO
dwMilliseconds);
if (nCount == 0 || nCount > MAXIMUM_WAIT_OBJECTS || !lpHandles) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return WAIT_FAILED;
}
@@ -463,7 +463,7 @@ DWORD WIN_FUNC WaitForMultipleObjects(DWORD nCount, const HANDLE *lpHandles, BOO
HandleMeta meta{};
auto obj = wibo::handles().getAs<WaitableObject>(lpHandles[i], &meta);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return WAIT_FAILED;
}
objects[i] = std::move(obj);
@@ -556,11 +556,11 @@ BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: InitializeCriticalSectionEx(%p, %u, 0x%x)\n", lpCriticalSection, dwSpinCount, Flags);
if (!lpCriticalSection) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (Flags & ~CRITICAL_SECTION_NO_DEBUG_INFO) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection));
@@ -572,7 +572,7 @@ BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCritica
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: InitializeCriticalSectionAndSpinCount(%p, %u)\n", lpCriticalSection, dwSpinCount);
if (!lpCriticalSection) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::memset(lpCriticalSection, 0, sizeof(*lpCriticalSection));
@@ -602,11 +602,11 @@ BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBO
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: InitOnceBeginInitialize(%p, %u, %p, %p)\n", lpInitOnce, dwFlags, fPending, lpContext);
if (!lpInitOnce) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (dwFlags & ~(INIT_ONCE_CHECK_ONLY | INIT_ONCE_ASYNC)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (fPending) {
@@ -622,11 +622,11 @@ BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpC
HOST_CONTEXT_GUARD();
DEBUG_LOG("STUB: InitOnceComplete(%p, %u, %p)\n", lpInitOnce, dwFlags, lpContext);
if (!lpInitOnce) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if ((dwFlags & INIT_ONCE_INIT_FAILED) && (dwFlags & INIT_ONCE_ASYNC)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
(void)lpContext;

3
dll/kernel32/sysinfoapi.cpp
View File

@@ -3,6 +3,7 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "internal.h"
#include "timeutil.h"
#include <cstring>
@@ -194,7 +195,7 @@ BOOL WIN_FUNC GetVersionExA(LPOSVERSIONINFOA lpVersionInformation) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetVersionExA(%p)\n", lpVersionInformation);
if (!lpVersionInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
std::memset(lpVersionInformation, 0, lpVersionInformation->dwOSVersionInfoSize);

51
dll/kernel32/timezoneapi.cpp
View File

@@ -2,6 +2,7 @@
#include "context.h"
#include "errors.h"
#include "internal.h"
#include "timeutil.h"
#include <cerrno>
@@ -14,22 +15,22 @@ BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lp
HOST_CONTEXT_GUARD();
DEBUG_LOG("SystemTimeToFileTime(%p, %p)\n", lpSystemTime, lpFileTime);
if (!lpSystemTime || !lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
int64_t seconds = 0;
uint32_t hundreds = 0;
if (!systemTimeToUnixParts(*lpSystemTime, seconds, hundreds)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FILETIME result;
if (!unixPartsToFileTime(seconds, hundreds, result)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (fileTimeToDuration(result) >= MAX_VALID_FILETIME) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpFileTime = result;
@@ -40,12 +41,12 @@ BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSy
HOST_CONTEXT_GUARD();
DEBUG_LOG("FileTimeToSystemTime(%p, %p)\n", lpFileTime, lpSystemTime);
if (!lpFileTime || !lpSystemTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint64_t ticks = fileTimeToDuration(*lpFileTime);
if (ticks >= MAX_VALID_FILETIME) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint64_t daysSince1601 = ticks / TICKS_PER_DAY;
@@ -69,45 +70,45 @@ BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpL
HOST_CONTEXT_GUARD();
DEBUG_LOG("FileTimeToLocalFileTime(%p, %p)\n", lpFileTime, lpLocalFileTime);
if (!lpFileTime || !lpLocalFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
int64_t seconds = 0;
uint32_t hundreds = 0;
if (!fileTimeToUnixParts(*lpFileTime, seconds, hundreds)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (seconds > static_cast<int64_t>(std::numeric_limits<time_t>::max()) ||
seconds < static_cast<int64_t>(std::numeric_limits<time_t>::min())) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
time_t unixTime = static_cast<time_t>(seconds);
struct tm localTm{};
#if defined(_POSIX_VERSION)
if (!localtime_r(&unixTime, &localTm)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
#else
struct tm *tmp = localtime(&unixTime);
if (!tmp) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
localTm = *tmp;
#endif
int64_t localAsUtcSeconds = 0;
if (!tmToUnixSeconds(localTm, localAsUtcSeconds)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
int64_t offsetSeconds = localAsUtcSeconds - seconds;
int64_t localSeconds = seconds + offsetSeconds;
FILETIME result;
if (!unixPartsToFileTime(localSeconds, hundreds, result)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpLocalFileTime = result;
@@ -118,12 +119,12 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM
HOST_CONTEXT_GUARD();
DEBUG_LOG("LocalFileTimeToFileTime(%p, %p)\n", lpLocalFileTime, lpFileTime);
if (!lpLocalFileTime || !lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint64_t ticks = fileTimeToDuration(*lpLocalFileTime);
if (ticks >= MAX_VALID_FILETIME) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint32_t hundredNs = static_cast<uint32_t>(ticks % HUNDRED_NS_PER_SECOND);
@@ -144,12 +145,12 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM
errno = 0;
time_t utcTime = mktime(&tmCopy);
if (utcTime == static_cast<time_t>(-1) && errno != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FILETIME result;
if (!unixPartsToFileTime(static_cast<int64_t>(utcTime), hundredNs, result)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpFileTime = result;
@@ -160,7 +161,7 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF
HOST_CONTEXT_GUARD();
DEBUG_LOG("DosDateTimeToFileTime(%04x, %04x, %p)\n", wFatDate, wFatTime, lpFileTime);
if (!lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
unsigned day = wFatDate & 0x1F;
@@ -170,7 +171,7 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF
unsigned minute = (wFatTime >> 5) & 0x3F;
unsigned hour = (wFatTime >> 11) & 0x1F;
if (day == 0 || month == 0 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 59) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
struct tm tmValue{};
@@ -183,7 +184,7 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF
tmValue.tm_isdst = -1;
time_t localSeconds = mktime(&tmValue);
if (localSeconds == static_cast<time_t>(-1)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint64_t ticks = (static_cast<uint64_t>(localSeconds) + UNIX_TIME_ZERO / HUNDRED_NS_PER_SECOND) * 10000000ULL;
@@ -195,23 +196,23 @@ BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate
HOST_CONTEXT_GUARD();
DEBUG_LOG("FileTimeToDosDateTime(%p, %p, %p)\n", lpFileTime, lpFatDate, lpFatTime);
if (!lpFileTime || !lpFatDate || !lpFatTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
uint64_t ticks = fileTimeToDuration(*lpFileTime);
if (ticks < UNIX_TIME_ZERO) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
time_t utcSeconds = static_cast<time_t>((ticks / 10000000ULL) - (UNIX_TIME_ZERO / HUNDRED_NS_PER_SECOND));
struct tm tmValue{};
if (!localtime_r(&utcSeconds, &tmValue)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
int year = tmValue.tm_year + 1900;
if (year < 1980 || year > 2107) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*lpFatDate = static_cast<WORD>(((year - 1980) << 9) | ((tmValue.tm_mon + 1) << 5) | tmValue.tm_mday);
@@ -224,7 +225,7 @@ DWORD WIN_FUNC GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformat
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetTimeZoneInformation(%p)\n", lpTimeZoneInformation);
if (!lpTimeZoneInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return TIME_ZONE_ID_INVALID;
}
std::memset(lpTimeZoneInformation, 0, sizeof(*lpTimeZoneInformation));

126
dll/kernel32/winbase.cpp
View File

@@ -83,7 +83,7 @@ bool tryHandleIntegerAtomPointer(const void *ptr, ATOM &atomOut) {
}
ATOM maybeAtom = static_cast<ATOM>(value & 0xFFFFu);
if (maybeAtom < kMinIntegerAtom || maybeAtom > kMaxIntegerAtom) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
atomOut = 0;
return true;
}
@@ -96,7 +96,7 @@ ATOM findAtomByNormalizedKey(const std::string &normalizedKey) {
std::lock_guard lk(table.mutex);
auto it = table.stringToAtom.find(normalizedKey);
if (it == table.stringToAtom.end()) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return 0;
}
return it->second;
@@ -114,7 +114,7 @@ ATOM tryParseIntegerAtomString(const std::string &value, bool &handled) {
}
handled = true;
if (parsed < kMinIntegerAtom || parsed > kMaxIntegerAtom) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
return static_cast<ATOM>(parsed);
@@ -137,7 +137,7 @@ ATOM addAtomByString(const std::string &value) {
return atom;
}
if (value.empty() || value.size() > 255) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string normalized = stringToLower(value);
@@ -153,7 +153,7 @@ ATOM addAtomByString(const std::string &value) {
}
ATOM newAtom = allocateStringAtomLocked(table);
if (newAtom == 0) {
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
kernel32::setLastError(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
AtomData data;
@@ -192,7 +192,7 @@ bool tryGetCurrentDirectoryPath(std::string &outPath) {
std::error_code ec;
std::filesystem::path cwd = std::filesystem::current_path(ec);
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
kernel32::setLastError(wibo::winErrorFromErrno(ec.value()));
return false;
}
outPath = files::pathToWindows(cwd);
@@ -208,13 +208,13 @@ bool computeLongWindowsPath(const std::string &inputPath, std::string &longPath)
auto hostPath = files::pathFromWindows(inputPath.c_str());
if (hostPath.empty()) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return false;
}
std::error_code ec;
if (!std::filesystem::exists(hostPath, ec)) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return false;
}
@@ -233,12 +233,12 @@ bool resolveDiskFreeSpaceStat(const char *rootPathName, struct statvfs &outBuf,
std::error_code ec;
hostPath = std::filesystem::current_path(ec);
if (ec) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return false;
}
}
if (hostPath.empty()) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return false;
}
@@ -251,7 +251,7 @@ bool resolveDiskFreeSpaceStat(const char *rootPathName, struct statvfs &outBuf,
if (!hostPath.is_absolute()) {
auto abs = std::filesystem::absolute(hostPath, ec);
if (ec) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
kernel32::setLastError(ERROR_PATH_NOT_FOUND);
return false;
}
hostPath = abs;
@@ -270,13 +270,13 @@ bool resolveDiskFreeSpaceStat(const char *rootPathName, struct statvfs &outBuf,
int savedErrno = errno;
if (savedErrno != ENOENT && savedErrno != ENOTDIR) {
wibo::lastError = wibo::winErrorFromErrno(savedErrno);
kernel32::setLastError(wibo::winErrorFromErrno(savedErrno));
return false;
}
std::filesystem::path parent = queryPath.parent_path();
if (parent == queryPath) {
wibo::lastError = wibo::winErrorFromErrno(savedErrno);
kernel32::setLastError(wibo::winErrorFromErrno(savedErrno));
return false;
}
if (parent.empty()) {
@@ -342,17 +342,17 @@ ATOM WIN_FUNC AddAtomA(LPCSTR lpString) {
}
DEBUG_LOG("AddAtomA(%s)\n", lpString ? lpString : "<null>");
if (!lpString) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
size_t len = strnlen(lpString, 256);
if (len == 0 || len >= 256) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string value(lpString, len);
ATOM result = addAtomByString(value);
DEBUG_LOG("AddAtomA -> %u (lastError=%u)\n", result, wibo::lastError);
DEBUG_LOG("AddAtomA -> %u (lastError=%u)\n", result, getLastError());
return result;
}
@@ -365,19 +365,19 @@ ATOM WIN_FUNC AddAtomW(LPCWSTR lpString) {
}
if (!lpString) {
DEBUG_LOG("AddAtomW(<null>)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
size_t len = wstrnlen(reinterpret_cast<const uint16_t *>(lpString), 256);
if (len == 0 || len >= 256) {
DEBUG_LOG("AddAtomW(invalid length)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string value = wideStringToString(reinterpret_cast<const uint16_t *>(lpString), static_cast<int>(len));
DEBUG_LOG("AddAtomW(%s)\n", value.c_str());
ATOM result = addAtomByString(value);
DEBUG_LOG("AddAtomW -> %u (lastError=%u)\n", result, wibo::lastError);
DEBUG_LOG("AddAtomW -> %u (lastError=%u)\n", result, getLastError());
return result;
}
@@ -390,17 +390,17 @@ ATOM WIN_FUNC FindAtomA(LPCSTR lpString) {
}
DEBUG_LOG("FindAtomA(%s)\n", lpString ? lpString : "<null>");
if (!lpString) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
size_t len = strnlen(lpString, 256);
if (len == 0 || len >= 256) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string value(lpString, len);
ATOM result = findAtomByString(value);
DEBUG_LOG("FindAtomA -> %u (lastError=%u)\n", result, wibo::lastError);
DEBUG_LOG("FindAtomA -> %u (lastError=%u)\n", result, getLastError());
return result;
}
@@ -413,19 +413,19 @@ ATOM WIN_FUNC FindAtomW(LPCWSTR lpString) {
}
if (!lpString) {
DEBUG_LOG("FindAtomW(<null>)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
size_t len = wstrnlen(reinterpret_cast<const uint16_t *>(lpString), 256);
if (len == 0 || len >= 256) {
DEBUG_LOG("FindAtomW(invalid length)\n");
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string value = wideStringToString(reinterpret_cast<const uint16_t *>(lpString), static_cast<int>(len));
DEBUG_LOG("FindAtomW(%s)\n", value.c_str());
ATOM result = findAtomByString(value);
DEBUG_LOG("FindAtomW -> %u (lastError=%u)\n", result, wibo::lastError);
DEBUG_LOG("FindAtomW -> %u (lastError=%u)\n", result, getLastError());
return result;
}
@@ -433,7 +433,7 @@ UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetAtomNameA(%u, %p, %d)\n", nAtom, lpBuffer, nSize);
if (!lpBuffer || nSize <= 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string value;
@@ -445,19 +445,19 @@ UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) {
std::lock_guard lk(table.mutex);
auto it = table.atomToData.find(nAtom);
if (it == table.atomToData.end()) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return 0;
}
value = it->second.original;
}
if (value.size() + 1 > static_cast<size_t>(nSize)) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
std::memcpy(lpBuffer, value.c_str(), value.size());
lpBuffer[value.size()] = '\0';
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, getLastError());
return written;
}
@@ -465,7 +465,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetAtomNameW(%u, %p, %d)\n", nAtom, lpBuffer, nSize);
if (!lpBuffer || nSize <= 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string narrow;
@@ -477,7 +477,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
std::lock_guard lk(table.mutex);
auto it = table.atomToData.find(nAtom);
if (it == table.atomToData.end()) {
wibo::lastError = ERROR_INVALID_HANDLE;
kernel32::setLastError(ERROR_INVALID_HANDLE);
return 0;
}
narrow = it->second.original;
@@ -485,7 +485,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
auto wide = stringToWideString(narrow.c_str(), narrow.size());
size_t needed = wide.size();
if (needed > static_cast<size_t>(nSize)) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
std::memcpy(lpBuffer, wide.data(), needed * sizeof(uint16_t));
@@ -493,7 +493,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
lpBuffer[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, getLastError());
return written;
}
@@ -523,7 +523,7 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId
std::string message = std::system_category().message(static_cast<int>(dwMessageId));
size_t length = message.length();
if (!lpBuffer || nSize == 0) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
std::strncpy(lpBuffer, message.c_str(), static_cast<size_t>(nSize));
@@ -531,7 +531,7 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId
if (static_cast<size_t>(nSize) > 0) {
lpBuffer[nSize - 1] = '\0';
}
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
lpBuffer[length] = '\0';
@@ -545,7 +545,7 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId
if (lpBuffer && nSize > 0) {
lpBuffer[0] = '\0';
}
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
setLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
@@ -571,7 +571,7 @@ BOOL WIN_FUNC SetDllDirectoryA(LPCSTR lpPathName) {
std::filesystem::path hostPath = files::pathFromWindows(lpPathName);
if (hostPath.empty() || !std::filesystem::exists(hostPath)) {
wibo::lastError = ERROR_PATH_NOT_FOUND;
setLastError(ERROR_PATH_NOT_FOUND);
return FALSE;
}
@@ -603,23 +603,23 @@ BOOL WIN_FUNC FindActCtxSectionStringW(DWORD dwFlags, const GUID *lpExtensionGui
ReturnedData);
if (lpExtensionGuid) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!ReturnedData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (dwFlags & ~FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ULONG originalSize = ReturnedData->cbSize;
if (originalSize < sizeof(ACTCTX_SECTION_KEYED_DATA)) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
@@ -646,7 +646,7 @@ BOOL WIN_FUNC FindActCtxSectionStringW(DWORD dwFlags, const GUID *lpExtensionGui
}
if (!matchedEntry) {
wibo::lastError = ERROR_SXS_KEY_NOT_FOUND;
setLastError(ERROR_SXS_KEY_NOT_FOUND);
return FALSE;
}
@@ -707,13 +707,13 @@ BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) {
if (nSize) {
*nSize = 0;
}
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (*nSize < kComputerNameRequiredSize) {
*nSize = kComputerNameRequiredSize;
wibo::lastError = ERROR_BUFFER_OVERFLOW;
setLastError(ERROR_BUFFER_OVERFLOW);
return FALSE;
}
@@ -729,13 +729,13 @@ BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) {
if (nSize) {
*nSize = 0;
}
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (*nSize < kComputerNameRequiredSize) {
*nSize = kComputerNameRequiredSize;
wibo::lastError = ERROR_BUFFER_OVERFLOW;
setLastError(ERROR_BUFFER_OVERFLOW);
return FALSE;
}
@@ -790,7 +790,7 @@ HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) {
}
void *result = doAlloc(static_cast<UINT>(uBytes), zero);
if (!result) {
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return nullptr;
}
// Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalAlloc.
@@ -816,7 +816,7 @@ HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) {
}
void *result = doRealloc(hMem, static_cast<UINT>(uBytes), zero);
if (!result && uBytes != 0) {
wibo::lastError = ERROR_NOT_SUPPORTED;
setLastError(ERROR_NOT_SUPPORTED);
return nullptr;
}
// Legacy Windows applications (pre-NX and DEP) may expect executable memory from LocalReAlloc.
@@ -895,7 +895,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize) {
DEBUG_LOG("GetSystemWow64DirectoryA(%p, %u)\n", lpBuffer, uSize);
(void)lpBuffer;
(void)uSize;
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
setLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
@@ -904,7 +904,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize) {
DEBUG_LOG("GetSystemWow64DirectoryW(%p, %u)\n", lpBuffer, uSize);
(void)lpBuffer;
(void)uSize;
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
setLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
@@ -959,11 +959,11 @@ DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
return required;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nBufferLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
std::memcpy(lpBuffer, path.c_str(), required);
@@ -984,11 +984,11 @@ DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
return required;
}
if (!lpBuffer) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (nBufferLength < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
std::copy(widePath.begin(), widePath.end(), lpBuffer);
@@ -999,14 +999,14 @@ int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetCurrentDirectoryA(%s)\n", lpPathName ? lpPathName : "(null)");
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
auto hostPath = files::pathFromWindows(lpPathName);
std::error_code ec;
std::filesystem::current_path(hostPath, ec);
if (ec) {
wibo::lastError = wibo::winErrorFromErrno(ec.value());
setLastError(wibo::winErrorFromErrno(ec.value()));
return 0;
}
return 1;
@@ -1016,7 +1016,7 @@ int WIN_FUNC SetCurrentDirectoryW(LPCWSTR lpPathName) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("SetCurrentDirectoryW\n");
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string path = wideStringToString(lpPathName);
@@ -1027,7 +1027,7 @@ DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetLongPathNameA(%s, %p, %u)\n", lpszShortPath ? lpszShortPath : "(null)", lpszLongPath, cchBuffer);
if (!lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -1042,11 +1042,11 @@ DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD
return required;
}
if (!lpszLongPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (cchBuffer < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
std::memcpy(lpszLongPath, longPath.c_str(), required);
@@ -1057,7 +1057,7 @@ DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWOR
HOST_CONTEXT_GUARD();
DEBUG_LOG("GetLongPathNameW(%p, %p, %u)\n", lpszShortPath, lpszLongPath, cchBuffer);
if (!lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
std::string input = wideStringToString(lpszShortPath);
@@ -1071,11 +1071,11 @@ DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWOR
return required;
}
if (!lpszLongPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (cchBuffer < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return required;
}
std::copy(wideLong.begin(), wideLong.end(), lpszLongPath);

10
dll/kernel32/wincon.cpp
View File

@@ -50,7 +50,7 @@ BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_B
DEBUG_LOG("STUB: GetConsoleScreenBufferInfo(%p, %p)\n", hConsoleOutput, lpConsoleScreenBufferInfo);
(void)hConsoleOutput;
if (!lpConsoleScreenBufferInfo) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
lpConsoleScreenBufferInfo->dwSize = {80, 25};
@@ -71,7 +71,7 @@ BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumb
*lpNumberOfCharsWritten = 0;
}
if (!lpBuffer && nNumberOfCharsToWrite != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -85,7 +85,7 @@ BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumb
return TRUE;
}
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
@@ -95,7 +95,7 @@ DWORD WIN_FUNC GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize) {
if (lpConsoleTitle && nSize > 0) {
lpConsoleTitle[0] = '\0';
}
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return 0;
}
@@ -105,7 +105,7 @@ DWORD WIN_FUNC GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) {
if (lpConsoleTitle && nSize > 0) {
lpConsoleTitle[0] = 0;
}
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
return 0;
}

41
dll/kernel32/winnls.cpp
View File

@@ -2,6 +2,7 @@
#include "context.h"
#include "errors.h"
#include "internal.h"
#include "strutil.h"
#include <algorithm>
@@ -106,7 +107,7 @@ BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) {
(void)CodePage;
if (!lpCPInfo) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
@@ -124,7 +125,7 @@ int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int
cchCount1, lpString2 ? lpString2 : "(null)", cchCount2);
(void)Locale;
if (!lpString1 || !lpString2) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -147,7 +148,7 @@ int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int
cchCount2);
(void)Locale;
if (!lpString1 || !lpString2) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -168,7 +169,7 @@ BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) {
DEBUG_LOG("IsValidLocale(%u, 0x%x)\n", Locale, dwFlags);
(void)Locale;
if (dwFlags != 0 && (dwFlags & ~(LCID_INSTALLED | LCID_SUPPORTED | LCID_ALTERNATE_SORTS)) != 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
return TRUE;
@@ -186,11 +187,11 @@ int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchD
return static_cast<int>(required);
}
if (!lpLCData || cchData < 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (static_cast<size_t>(cchData) < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
@@ -211,11 +212,11 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch
return static_cast<int>(required);
}
if (!lpLCData || cchData < 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
if (static_cast<size_t>(cchData) < required) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
@@ -224,16 +225,18 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch
}
BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags) {
{
HOST_CONTEXT_GUARD();
DEBUG_LOG("EnumSystemLocalesA(%p, 0x%x)\n", lpLocaleEnumProc, dwFlags);
(void)dwFlags;
if (!lpLocaleEnumProc) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
// Return to guest context before callback
char localeId[] = "00000409"; // en-US
BOOL callbackResult = lpLocaleEnumProc(localeId);
return callbackResult;
return lpLocaleEnumProc(localeId);
}
LCID WIN_FUNC GetUserDefaultLCID() {
@@ -262,7 +265,7 @@ BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) {
return FALSE;
};
wibo::lastError = ERROR_SUCCESS;
setLastError(ERROR_SUCCESS);
switch (CodePage) {
case 932: // Shift-JIS
return inRanges({{0x81, 0x9F}, {0xE0, 0xFC}});
@@ -285,14 +288,14 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc
DEBUG_LOG("LCMapStringW(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest);
(void)Locale;
if (!lpSrcStr || cchSrc == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
bool nullTerminated = cchSrc < 0;
size_t srcLen = nullTerminated ? (wstrlen(lpSrcStr) + 1) : static_cast<size_t>(cchSrc);
if (srcLen == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -300,13 +303,13 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc
return static_cast<int>(srcLen);
}
if (cchDest < static_cast<int>(srcLen)) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
if (dwMapFlags & (0x00000400u | 0x00000800u)) { // LCMAP_SORTKEY | LCMAP_BYTEREV
DEBUG_LOG("LCMapStringW: unsupported mapping flags 0x%x\n", dwMapFlags);
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -331,7 +334,7 @@ int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cch
HOST_CONTEXT_GUARD();
DEBUG_LOG("LCMapStringA(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest);
if (!lpSrcStr) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
int length = cchSrc;
@@ -344,7 +347,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;
setLastError(ERROR_SUCCESS);
return 0;
}
@@ -355,7 +358,7 @@ int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cch
auto mapped = wideStringToString(wideDest.data(), wideResult);
size_t bytesToCopy = mapped.size() + 1;
if (static_cast<size_t>(cchDest) < bytesToCopy) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}
std::memcpy(lpDestStr, mapped.c_str(), bytesToCopy);

6
dll/kernel32/wow64apiset.cpp
View File

@@ -28,18 +28,18 @@ BOOL WIN_FUNC IsWow64Process(HANDLE hProcess, PBOOL Wow64Process) {
HOST_CONTEXT_GUARD();
DEBUG_LOG("IsWow64Process(%p, %p)\n", hProcess, Wow64Process);
if (!Wow64Process) {
wibo::lastError = ERROR_INVALID_PARAMETER;
setLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!isPseudoCurrentProcessHandle(hProcess)) {
if (!hProcess) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
auto obj = wibo::handles().getAs<ProcessObject>(hProcess);
if (!obj) {
wibo::lastError = ERROR_INVALID_HANDLE;
setLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
}

35
dll/user32.cpp
View File

@@ -1,10 +1,12 @@
#include "common.h"
#include "context.h"
#include "errors.h"
#include "kernel32/internal.h"
#include "modules.h"
#include "resources.h"
namespace user32 {
constexpr uint32_t RT_STRING_ID = 6;
constexpr uintptr_t kDefaultKeyboardLayout = 0x04090409;
constexpr int UOI_FLAGS = 1;
@@ -140,10 +142,8 @@ namespace user32 {
return reinterpret_cast<HWINSTA>(&kWindowStationStub);
}
BOOL WIN_FUNC GetUserObjectInformationA(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength,
LPDWORD lpnLengthNeeded) {
DEBUG_LOG("GetUserObjectInformationA(%p, %d, %p, %u, %p)\n", hObj, nIndex, pvInfo, nLength,
lpnLengthNeeded);
BOOL WIN_FUNC GetUserObjectInformationA(HANDLE hObj, int nIndex, PVOID pvInfo, DWORD nLength, LPDWORD lpnLengthNeeded) {
DEBUG_LOG("GetUserObjectInformationA(%p, %d, %p, %u, %p)\n", hObj, nIndex, pvInfo, nLength, lpnLengthNeeded);
(void)hObj;
if (lpnLengthNeeded) {
@@ -151,12 +151,12 @@ namespace user32 {
}
if (nIndex != UOI_FLAGS) {
wibo::lastError = ERROR_CALL_NOT_IMPLEMENTED;
kernel32::setLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
if (!pvInfo || nLength < sizeof(USEROBJECTFLAGS)) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
@@ -171,17 +171,24 @@ namespace user32 {
DEBUG_LOG("GetActiveWindow()\n");
return nullptr;
}
}
} // namespace user32
static void *resolveByName(const char *name) {
if (strcmp(name, "LoadStringA") == 0) return (void *) user32::LoadStringA;
if (strcmp(name, "LoadStringW") == 0) return (void *) user32::LoadStringW;
if (strcmp(name, "MessageBoxA") == 0) return (void *) user32::MessageBoxA;
if (strcmp(name, "GetKeyboardLayout") == 0) return (void *) user32::GetKeyboardLayout;
if (strcmp(name, "GetProcessWindowStation") == 0) return (void *) user32::GetProcessWindowStation;
if (strcmp(name, "GetUserObjectInformationA") == 0) return (void *) user32::GetUserObjectInformationA;
if (strcmp(name, "GetActiveWindow") == 0) return (void *) user32::GetActiveWindow;
if (strcmp(name, "LoadStringA") == 0)
return (void *)user32::LoadStringA;
if (strcmp(name, "LoadStringW") == 0)
return (void *)user32::LoadStringW;
if (strcmp(name, "MessageBoxA") == 0)
return (void *)user32::MessageBoxA;
if (strcmp(name, "GetKeyboardLayout") == 0)
return (void *)user32::GetKeyboardLayout;
if (strcmp(name, "GetProcessWindowStation") == 0)
return (void *)user32::GetProcessWindowStation;
if (strcmp(name, "GetUserObjectInformationA") == 0)
return (void *)user32::GetUserObjectInformationA;
if (strcmp(name, "GetActiveWindow") == 0)
return (void *)user32::GetActiveWindow;
return nullptr;
}

11
dll/version.cpp
View File

@@ -2,6 +2,7 @@
#include "context.h"
#include "errors.h"
#include "files.h"
#include "kernel32/internal.h"
#include "modules.h"
#include "resources.h"
#include "strutil.h"
@@ -160,7 +161,7 @@ bool splitSubBlock(const std::string &subBlock, std::vector<std::string> &segmen
bool loadVersionResource(const char *fileName, std::vector<uint8_t> &buffer) {
if (!fileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return false;
}
@@ -168,14 +169,14 @@ bool loadVersionResource(const char *fileName, std::vector<uint8_t> &buffer) {
std::string hostPathStr = hostPath.string();
FILE *fp = std::fopen(hostPathStr.c_str(), "rb");
if (!fp) {
wibo::lastError = ERROR_FILE_NOT_FOUND;
kernel32::setLastError(ERROR_FILE_NOT_FOUND);
return false;
}
wibo::Executable executable;
if (!executable.loadPE(fp, false)) {
std::fclose(fp);
wibo::lastError = ERROR_BAD_EXE_FORMAT;
kernel32::setLastError(ERROR_BAD_EXE_FORMAT);
return false;
}
@@ -217,7 +218,7 @@ unsigned int WIN_FUNC GetFileVersionInfoA(const char *lptstrFilename, unsigned i
(void)dwHandle;
DEBUG_LOG("GetFileVersionInfoA(%s, %u, %p)\n", lptstrFilename, dwLen, lpData);
if (!lpData || dwLen == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return 0;
}
@@ -226,7 +227,7 @@ unsigned int WIN_FUNC GetFileVersionInfoA(const char *lptstrFilename, unsigned i
return 0;
if (buffer.size() > dwLen) {
wibo::lastError = ERROR_INSUFFICIENT_BUFFER;
kernel32::setLastError(ERROR_INSUFFICIENT_BUFFER);
return 0;
}

1
src/common.h
View File

@@ -398,7 +398,6 @@ static_assert(sizeof(TIB) >= 0x1000, "TIB too small");
namespace wibo {
extern thread_local uint32_t lastError;
extern char **argv;
extern int argc;
extern std::filesystem::path guestExecutablePath;

3
src/loader.cpp
View File

@@ -1,5 +1,6 @@
#include "common.h"
#include "errors.h"
#include "kernel32/internal.h"
#include "modules.h"
#include <algorithm>
@@ -390,7 +391,7 @@ bool wibo::Executable::resolveImports() {
uint32_t *addressTable = fromRVA(dir->importAddressTable);
ModuleInfo *module = loadModule(dllName);
if (!module && wibo::lastError != ERROR_MOD_NOT_FOUND) {
if (!module && kernel32::getLastError() != ERROR_MOD_NOT_FOUND) {
DEBUG_LOG("Failed to load import module %s\n", dllName);
// lastError is set by loadModule
importsResolved = false;

3
src/main.cpp
View File

@@ -24,7 +24,6 @@
#include <unistd.h>
#include <vector>
thread_local uint32_t wibo::lastError = 0;
char **wibo::argv;
int wibo::argc;
std::filesystem::path wibo::guestExecutablePath;
@@ -605,7 +604,7 @@ int main(int argc, char **argv) {
}
// Reset last error
wibo::lastError = 0;
kernel32::setLastError(0);
// Invoke the damn thing
{

29
src/modules.cpp
View File

@@ -4,6 +4,7 @@
#include "context.h"
#include "errors.h"
#include "files.h"
#include "kernel32/internal.h"
#include "strutil.h"
#include "tls.h"
@@ -562,7 +563,7 @@ BOOL callDllMain(wibo::ModuleInfo &info, DWORD reason, LPVOID reserved) {
}
// Reset last error
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
using DllMainFunc = BOOL(WIN_FUNC *)(HMODULE, DWORD, LPVOID);
auto dllMain = reinterpret_cast<DllMainFunc>(entry);
@@ -943,7 +944,7 @@ bool initializeModuleTls(ModuleInfo &module) {
size_t requiredModuleCapacity = reg->tlsModuleSlots.size();
if (!wibo::tls::ensureModulePointerCapacity(requiredModuleCapacity)) {
releaseModuleTlsSlot(*reg, loaderIndex);
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
kernel32::setLastError(ERROR_NOT_ENOUGH_MEMORY);
return false;
}
info.loaderIndex = loaderIndex;
@@ -958,7 +959,7 @@ bool initializeModuleTls(ModuleInfo &module) {
if (info.indexLocation) {
*info.indexLocation = 0;
}
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
kernel32::setLastError(ERROR_NOT_ENOUGH_MEMORY);
return false;
}
info.index = apiIndex;
@@ -1001,11 +1002,11 @@ bool initializeModuleTls(ModuleInfo &module) {
if (info.indexLocation) {
*info.indexLocation = 0;
}
wibo::lastError = ERROR_NOT_ENOUGH_MEMORY;
kernel32::setLastError(ERROR_NOT_ENOUGH_MEMORY);
return false;
}
runModuleTlsCallbacks(module, TLS_PROCESS_ATTACH);
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
return true;
}
@@ -1079,7 +1080,7 @@ void notifyDllThreadAttach() {
for (wibo::ModuleInfo *info : targets) {
callDllMain(*info, DLL_THREAD_ATTACH, nullptr);
}
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
}
void notifyDllThreadDetach() {
@@ -1106,7 +1107,7 @@ void notifyDllThreadDetach() {
freeModuleTlsForThread(**it, tib);
}
}
wibo::lastError = ERROR_SUCCESS;
kernel32::setLastError(ERROR_SUCCESS);
}
BOOL disableThreadNotifications(ModuleInfo *info) {
@@ -1135,7 +1136,7 @@ ModuleInfo *findLoadedModule(const char *name) {
ModuleInfo *loadModule(const char *dllName) {
if (!dllName || *dllName == '\0') {
lastError = ERROR_INVALID_PARAMETER;
kernel32::setLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
std::string requested(dllName);
@@ -1198,14 +1199,14 @@ ModuleInfo *loadModule(const char *dllName) {
DEBUG_LOG(" resolveImports failed for %s\n", raw->originalName.c_str());
reg.lock.lock();
reg->modulesByKey.erase(key);
diskError = wibo::lastError;
diskError = kernel32::getLastError();
return nullptr;
}
if (!initializeModuleTls(*raw)) {
DEBUG_LOG(" initializeModuleTls failed for %s\n", raw->originalName.c_str());
reg.lock.lock();
reg->modulesByKey.erase(key);
diskError = wibo::lastError;
diskError = kernel32::getLastError();
return nullptr;
}
reg.lock.lock();
@@ -1230,7 +1231,7 @@ ModuleInfo *loadModule(const char *dllName) {
reg->pinnedModules.erase(raw);
reg->modulesByKey.erase(key);
diskError = ERROR_DLL_INIT_FAILED;
wibo::lastError = ERROR_DLL_INIT_FAILED;
kernel32::setLastError(ERROR_DLL_INIT_FAILED);
return nullptr;
}
return raw;
@@ -1266,7 +1267,7 @@ ModuleInfo *loadModule(const char *dllName) {
DEBUG_LOG(" replaced builtin module %s with external copy\n", requested.c_str());
return external;
} else if (diskError != ERROR_MOD_NOT_FOUND) {
lastError = diskError;
kernel32::setLastError(diskError);
return nullptr;
}
}
@@ -1278,7 +1279,7 @@ ModuleInfo *loadModule(const char *dllName) {
DEBUG_LOG(" loaded external module %s\n", requested.c_str());
return external;
} else if (diskError != ERROR_MOD_NOT_FOUND) {
lastError = diskError;
kernel32::setLastError(diskError);
return nullptr;
}
@@ -1299,7 +1300,7 @@ ModuleInfo *loadModule(const char *dllName) {
return builtin;
}
lastError = (diskError != ERROR_SUCCESS) ? diskError : ERROR_MOD_NOT_FOUND;
kernel32::setLastError((diskError != ERROR_SUCCESS) ? diskError : ERROR_MOD_NOT_FOUND);
return nullptr;
}

15
src/resources.cpp
View File

@@ -2,6 +2,7 @@
#include "common.h"
#include "errors.h"
#include "kernel32/internal.h"
#include "modules.h"
namespace {
@@ -146,39 +147,39 @@ bool Executable::findResource(const ResourceIdentifier &type, const ResourceIden
std::optional<uint16_t> language, ResourceLocation &out) const {
const uint8_t *base = reinterpret_cast<const uint8_t *>(rsrcBase);
if (!base) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return false;
}
const auto *root = reinterpret_cast<const ImageResourceDirectory *>(base);
const auto *typeEntry = findEntry(base, root, type, rsrcSize);
if (!typeEntry) {
wibo::lastError = ERROR_RESOURCE_TYPE_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_TYPE_NOT_FOUND);
return false;
}
const auto *nameDir = entryAsDirectory(base, typeEntry, rsrcSize);
if (!nameDir) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return false;
}
const auto *nameEntry = findEntry(base, nameDir, name, rsrcSize);
if (!nameEntry) {
wibo::lastError = ERROR_RESOURCE_NAME_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
return false;
}
const auto *langDir = entryAsDirectory(base, nameEntry, rsrcSize);
if (!langDir) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return false;
}
uint16_t chosenLang = language.value_or(0);
const auto *langEntry = selectLanguageEntry(langDir, language, chosenLang);
if (!langEntry) {
wibo::lastError = ERROR_RESOURCE_LANG_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_LANG_NOT_FOUND);
return false;
}
const auto *dataEntry = entryAsData(base, langEntry, rsrcSize);
if (!dataEntry) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
kernel32::setLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
return false;
}
out.dataEntry = dataEntry;