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

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

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

1
dll/kernel32/debugapi.cpp
View File

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

7
dll/kernel32/errhandlingapi.cpp
View File

@@ -14,17 +14,20 @@ namespace kernel32 {
void setLastErrorFromErrno() { wibo::lastError = wibo::winErrorFromErrno(errno); }
DWORD WIN_FUNC GetLastError() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLastError() -> %u\n", wibo::lastError);
return wibo::lastError;
}
void WIN_FUNC SetLastError(DWORD dwErrCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetLastError(%u)\n", dwErrCode);
wibo::lastError = dwErrCode;
}
void WIN_FUNC RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments,
const ULONG_PTR *lpArguments) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("RaiseException(0x%x, 0x%x, %u, %p)\n", dwExceptionCode, dwExceptionFlags, nNumberOfArguments,
lpArguments);
(void)dwExceptionFlags;
@@ -34,12 +37,14 @@ void WIN_FUNC RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWOR
}
PVOID WIN_FUNC AddVectoredExceptionHandler(ULONG First, PVECTORED_EXCEPTION_HANDLER Handler) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: AddVectoredExceptionHandler(%u, %p)\n", First, Handler);
return reinterpret_cast<PVOID>(Handler);
}
LPTOP_LEVEL_EXCEPTION_FILTER WIN_FUNC
SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetUnhandledExceptionFilter(%p)\n", lpTopLevelExceptionFilter);
LPTOP_LEVEL_EXCEPTION_FILTER previous = g_topLevelExceptionFilter;
g_topLevelExceptionFilter = lpTopLevelExceptionFilter;
@@ -47,11 +52,13 @@ SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilt
}
LONG WIN_FUNC UnhandledExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: UnhandledExceptionFilter(%p)\n", ExceptionInfo);
return EXCEPTION_EXECUTE_HANDLER;
}
UINT WIN_FUNC SetErrorMode(UINT uMode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetErrorMode(%u)\n", uMode);
UINT previous = g_processErrorMode;
g_processErrorMode = uMode;

4
dll/kernel32/fibersapi.cpp
View File

@@ -13,6 +13,7 @@ LPVOID g_flsValues[kMaxFlsValues] = {nullptr};
namespace kernel32 {
DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FlsAlloc(%p)", lpCallback);
// If the function succeeds, the return value is an FLS index initialized to zero.
for (DWORD i = 0; i < kMaxFlsValues; i++) {
@@ -29,6 +30,7 @@ DWORD WIN_FUNC FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) {
}
BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FlsFree(%u)\n", dwFlsIndex);
if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) {
g_flsValuesUsed[dwFlsIndex] = false;
@@ -40,6 +42,7 @@ BOOL WIN_FUNC FlsFree(DWORD dwFlsIndex) {
}
PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("FlsGetValue(%u)\n", dwFlsIndex);
PVOID result = nullptr;
if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) {
@@ -54,6 +57,7 @@ PVOID WIN_FUNC FlsGetValue(DWORD dwFlsIndex) {
}
BOOL WIN_FUNC FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("FlsSetValue(%u, %p)\n", dwFlsIndex, lpFlsData);
if (dwFlsIndex >= 0 && dwFlsIndex < kMaxFlsValues && g_flsValuesUsed[dwFlsIndex]) {
g_flsValues[dwFlsIndex] = lpFlsData;

39
dll/kernel32/fileapi.cpp
View File

@@ -294,6 +294,7 @@ void resetOverlappedEvent(OVERLAPPED *ov) {
} // namespace
DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
WIN_API_SEGMENT_GUARD();
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return INVALID_FILE_ATTRIBUTES;
@@ -332,6 +333,7 @@ DWORD WIN_FUNC GetFileAttributesA(LPCSTR lpFileName) {
}
DWORD WIN_FUNC GetFileAttributesW(LPCWSTR lpFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFileAttributesW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -342,6 +344,7 @@ DWORD WIN_FUNC GetFileAttributesW(LPCWSTR lpFileName) {
}
UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeA(%s)\n", lpRootPathName ? lpRootPathName : "(null)");
(void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
@@ -349,6 +352,7 @@ UINT WIN_FUNC GetDriveTypeA(LPCSTR lpRootPathName) {
}
UINT WIN_FUNC GetDriveTypeW(LPCWSTR lpRootPathName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetDriveTypeW(%p)\n", lpRootPathName);
(void)lpRootPathName;
wibo::lastError = ERROR_SUCCESS;
@@ -359,6 +363,7 @@ BOOL WIN_FUNC GetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameBuf
LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength,
LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer,
DWORD nFileSystemNameSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetVolumeInformationA(%s)\n", lpRootPathName ? lpRootPathName : "(null)");
if (lpVolumeNameBuffer && nVolumeNameSize > 0) {
lpVolumeNameBuffer[0] = '\0';
@@ -388,6 +393,7 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB
LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength,
LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer,
DWORD nFileSystemNameSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetVolumeInformationW(%p)\n", lpRootPathName);
if (lpVolumeNameBuffer && nVolumeNameSize > 0) {
lpVolumeNameBuffer[0] = 0;
@@ -416,6 +422,7 @@ BOOL WIN_FUNC GetVolumeInformationW(LPCWSTR lpRootPathName, LPWSTR lpVolumeNameB
}
LONG WIN_FUNC CompareFileTime(const FILETIME *lpFileTime1, const FILETIME *lpFileTime2) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CompareFileTime(%p, %p)\n", lpFileTime1, lpFileTime2);
auto toInt64 = [](const FILETIME *ft) -> int64_t {
if (!ft) {
@@ -437,6 +444,7 @@ LONG WIN_FUNC CompareFileTime(const FILETIME *lpFileTime1, const FILETIME *lpFil
BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("WriteFile(%p, %p, %u, %p, %p)\n", hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten,
lpOverlapped);
wibo::lastError = ERROR_SUCCESS;
@@ -494,6 +502,7 @@ BOOL WIN_FUNC WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWr
}
BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FlushFileBuffers(%p)\n", hFile);
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
@@ -510,6 +519,7 @@ BOOL WIN_FUNC FlushFileBuffers(HANDLE hFile) {
BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ReadFile(%p, %u)\n", hFile, nNumberOfBytesToRead);
wibo::lastError = ERROR_SUCCESS;
@@ -568,6 +578,7 @@ BOOL WIN_FUNC ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead
HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) {
WIN_API_SEGMENT_GUARD();
(void)hTemplateFile;
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -789,6 +800,7 @@ HANDLE WIN_FUNC CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwSh
HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateFileW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -800,6 +812,7 @@ HANDLE WIN_FUNC CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwS
}
BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) {
WIN_API_SEGMENT_GUARD();
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
DEBUG_LOG("DeleteFileA(NULL) -> ERROR_INVALID_PARAMETER\n");
@@ -816,6 +829,7 @@ BOOL WIN_FUNC DeleteFileA(LPCSTR lpFileName) {
}
BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("DeleteFileW -> ");
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -826,6 +840,7 @@ BOOL WIN_FUNC DeleteFileW(LPCWSTR lpFileName) {
}
BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("MoveFileA(%s, %s)\n", lpExistingFileName ? lpExistingFileName : "(null)",
lpNewFileName ? lpNewFileName : "(null)");
if (!lpExistingFileName || !lpNewFileName) {
@@ -855,6 +870,7 @@ BOOL WIN_FUNC MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) {
}
BOOL WIN_FUNC MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("MoveFileW -> ");
if (!lpExistingFileName || !lpNewFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -866,6 +882,7 @@ BOOL WIN_FUNC MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName) {
}
DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetFilePointer(%p, %ld, %p, %u)\n", hFile, static_cast<long>(lDistanceToMove), lpDistanceToMoveHigh,
dwMoveMethod);
if (hFile == nullptr) {
@@ -907,6 +924,7 @@ DWORD WIN_FUNC SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistan
BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER lpNewFilePointer,
DWORD dwMoveMethod) {
WIN_API_SEGMENT_GUARD();
if (hFile == nullptr) {
wibo::lastError = ERROR_INVALID_HANDLE;
return FALSE;
@@ -952,6 +970,7 @@ BOOL WIN_FUNC SetFilePointerEx(HANDLE hFile, LARGE_INTEGER liDistanceToMove, PLA
}
BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetEndOfFile(%p)\n", hFile);
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@@ -974,6 +993,7 @@ BOOL WIN_FUNC SetEndOfFile(HANDLE hFile) {
}
BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) {
WIN_API_SEGMENT_GUARD();
(void)lpSecurityAttributes;
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -990,6 +1010,7 @@ BOOL WIN_FUNC CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecuri
}
BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
WIN_API_SEGMENT_GUARD();
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE;
@@ -1005,6 +1026,7 @@ BOOL WIN_FUNC RemoveDirectoryA(LPCSTR lpPathName) {
}
BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
WIN_API_SEGMENT_GUARD();
(void)dwFileAttributes;
if (!lpFileName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1016,6 +1038,7 @@ BOOL WIN_FUNC SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes) {
}
DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFileSize(%p, %p) ", hFile, lpFileSizeHigh);
// TODO access check
auto file = wibo::handles().getAs<FileObject>(hFile);
@@ -1043,6 +1066,7 @@ DWORD WIN_FUNC GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime,
LPFILETIME lpLastWriteTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFileTime(%p, %p, %p, %p)\n", hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@@ -1085,6 +1109,7 @@ BOOL WIN_FUNC GetFileTime(HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lp
BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FILETIME *lpLastAccessTime,
const FILETIME *lpLastWriteTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetFileTime(%p, %p, %p, %p)\n", hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
HandleMeta meta{};
auto file = wibo::handles().getAs<FileObject>(hFile, &meta);
@@ -1155,6 +1180,7 @@ BOOL WIN_FUNC SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, const FI
}
BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFileInformationByHandle(%p, %p)\n", hFile, lpFileInformation);
if (!lpFileInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1193,6 +1219,7 @@ BOOL WIN_FUNC GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMAT
}
DWORD WIN_FUNC GetFileType(HANDLE hFile) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFileType(%p) ", hFile);
auto file = wibo::handles().getAs<FileObject>(hFile);
if (!file || !file->valid()) {
@@ -1222,6 +1249,7 @@ DWORD WIN_FUNC GetFileType(HANDLE hFile) {
}
DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFullPathNameA(%s, %u)\n", lpFileName ? lpFileName : "(null)", nBufferLength);
if (lpFilePart) {
@@ -1274,6 +1302,7 @@ DWORD WIN_FUNC GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lp
}
DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetFullPathNameW(%p, %u)\n", lpFileName, nBufferLength);
if (lpFilePart) {
@@ -1327,6 +1356,7 @@ DWORD WIN_FUNC GetFullPathNameW(LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR
}
DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetShortPathNameA(%s)\n", lpszLongPath ? lpszLongPath : "(null)");
if (!lpszLongPath || !lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1347,6 +1377,7 @@ DWORD WIN_FUNC GetShortPathNameA(LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD
}
DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer) {
WIN_API_SEGMENT_GUARD();
if (!lpszLongPath || !lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return 0;
@@ -1368,6 +1399,7 @@ DWORD WIN_FUNC GetShortPathNameW(LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWO
}
UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetTempFileNameA(%s, %s, %u)\n", lpPathName ? lpPathName : "(null)",
lpPrefixString ? lpPrefixString : "(null)", uUnique);
if (!lpPathName || !lpPrefixString || !lpTempFileName) {
@@ -1410,6 +1442,7 @@ UINT WIN_FUNC GetTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uU
}
DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetTempPathA(%u, %p)\n", nBufferLength, lpBuffer);
if (nBufferLength == 0 || lpBuffer == nullptr) {
@@ -1437,6 +1470,7 @@ DWORD WIN_FUNC GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer) {
}
HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindFirstFileA(%s, %p)", lpFileName ? lpFileName : "(null)", lpFindFileData);
if (!lpFileName || !lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1479,6 +1513,7 @@ HANDLE WIN_FUNC FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileD
}
HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindFirstFileW(%p, %p)", lpFileName, lpFindFileData);
if (!lpFileName || !lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1523,6 +1558,7 @@ HANDLE WIN_FUNC FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFile
HANDLE WIN_FUNC FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindFirstFileExA(%s, %d, %p, %d, %p, 0x%x) -> ", lpFileName ? lpFileName : "(null)", fInfoLevelId,
lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
(void)fInfoLevelId;
@@ -1533,6 +1569,7 @@ HANDLE WIN_FUNC FindFirstFileExA(LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLeve
}
BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindNextFileA(%p, %p)\n", hFindFile, lpFindFileData);
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1561,6 +1598,7 @@ BOOL WIN_FUNC FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData)
}
BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindNextFileW(%p, %p)\n", hFindFile, lpFindFileData);
if (!lpFindFileData) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1589,6 +1627,7 @@ BOOL WIN_FUNC FindNextFileW(HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData)
}
BOOL WIN_FUNC FindClose(HANDLE hFindFile) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindClose(%p)\n", hFindFile);
if (isPseudoHandle(hFindFile) || hFindFile == nullptr) {
wibo::lastError = ERROR_SUCCESS;

2
dll/kernel32/handleapi.cpp
View File

@@ -11,6 +11,7 @@ namespace kernel32 {
BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle,
LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("DuplicateHandle(%p, %p, %p, %p, %x, %d, %x)\n", hSourceProcessHandle, hSourceHandle,
hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions);
(void)dwDesiredAccess;
@@ -62,6 +63,7 @@ BOOL WIN_FUNC DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle,
}
BOOL WIN_FUNC CloseHandle(HANDLE hObject) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CloseHandle(%p)\n", hObject);
if (!wibo::handles().release(hObject)) {
wibo::lastError = ERROR_INVALID_HANDLE;

26
dll/kernel32/heapapi.cpp
View File

@@ -76,6 +76,7 @@ HeapObject::~HeapObject() {
namespace kernel32 {
HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapCreate(%u, %zu, %zu)\n", flOptions, dwInitialSize, dwMaximumSize);
if (dwMaximumSize != 0 && dwInitialSize > dwMaximumSize) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -101,6 +102,7 @@ HANDLE WIN_FUNC HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaxim
}
BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapDestroy(%p)\n", hHeap);
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record) {
@@ -119,6 +121,7 @@ BOOL WIN_FUNC HeapDestroy(HANDLE hHeap) {
}
HANDLE WIN_FUNC GetProcessHeap() {
WIN_API_SEGMENT_GUARD();
ensureProcessHeapInitialized();
wibo::lastError = ERROR_SUCCESS;
DEBUG_LOG("GetProcessHeap() -> %p\n", g_processHeapHandle);
@@ -127,6 +130,7 @@ HANDLE WIN_FUNC GetProcessHeap() {
BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation,
SIZE_T HeapInformationLength) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapSetInformation(%p, %d, %p, %zu)\n", HeapHandle, static_cast<int>(HeapInformationClass),
HeapInformation, HeapInformationLength);
auto record = wibo::handles().getAs<HeapObject>(HeapHandle);
@@ -162,6 +166,7 @@ BOOL WIN_FUNC HeapSetInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapI
}
LPVOID WIN_FUNC HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapAlloc(%p, 0x%x, %zu) ", hHeap, dwFlags, dwBytes);
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record) {
@@ -181,6 +186,7 @@ LPVOID WIN_FUNC HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) {
}
LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapReAlloc(%p, 0x%x, %p, %zu) ", hHeap, dwFlags, lpMem, dwBytes);
auto record = wibo::handles().getAs<HeapObject>(hHeap);
if (!record) {
@@ -258,6 +264,7 @@ LPVOID WIN_FUNC HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dw
}
SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapSize(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem);
(void)dwFlags;
auto record = wibo::handles().getAs<HeapObject>(hHeap);
@@ -274,16 +281,18 @@ SIZE_T WIN_FUNC HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return static_cast<SIZE_T>(-1);
}
// if (!mi_heap_check_owned(record->heap, const_cast<LPVOID>(lpMem))) {
// wibo::lastError = ERROR_INVALID_PARAMETER;
// return static_cast<SIZE_T>(-1);
// }
if (!mi_heap_check_owned(record->heap, const_cast<LPVOID>(lpMem))) {
DEBUG_LOG("HeapSize: block %p not owned by heap %p\n", lpMem, record->heap);
wibo::lastError = ERROR_INVALID_PARAMETER;
return static_cast<SIZE_T>(-1);
}
size_t size = mi_usable_size(lpMem);
wibo::lastError = ERROR_SUCCESS;
return static_cast<SIZE_T>(size);
}
BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("HeapFree(%p, 0x%x, %p)\n", hHeap, dwFlags, lpMem);
(void)dwFlags;
if (lpMem == nullptr) {
@@ -302,10 +311,11 @@ BOOL WIN_FUNC HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) {
wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE;
}
// if (!mi_heap_check_owned(record->heap, lpMem)) {
// wibo::lastError = ERROR_INVALID_PARAMETER;
// return FALSE;
// }
if (!mi_heap_check_owned(record->heap, lpMem)) {
DEBUG_LOG("HeapFree: block %p not owned by heap %p\n", lpMem, record->heap);
wibo::lastError = ERROR_INVALID_PARAMETER;
return FALSE;
}
mi_free(lpMem);
DEBUG_LOG("-> SUCCESS\n");
wibo::lastError = ERROR_SUCCESS;

5
dll/kernel32/interlockedapi.cpp
View File

@@ -6,16 +6,19 @@
namespace kernel32 {
LONG WIN_FUNC InterlockedIncrement(LONG volatile *Addend) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("InterlockedIncrement(%p)\n", Addend);
return ++(*Addend);
}
LONG WIN_FUNC InterlockedDecrement(LONG volatile *Addend) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("InterlockedDecrement(%p)\n", Addend);
return --(*Addend);
}
LONG WIN_FUNC InterlockedExchange(LONG volatile *Target, LONG Value) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("InterlockedExchange(%p, %ld)\n", Target, static_cast<long>(Value));
LONG initial = *Target;
*Target = Value;
@@ -23,6 +26,7 @@ LONG WIN_FUNC InterlockedExchange(LONG volatile *Target, LONG Value) {
}
LONG WIN_FUNC InterlockedCompareExchange(LONG volatile *Destination, LONG Exchange, LONG Comperand) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("InterlockedCompareExchange(%p, %ld, %ld)\n", Destination, static_cast<long>(Exchange),
static_cast<long>(Comperand));
LONG original = *Destination;
@@ -33,6 +37,7 @@ LONG WIN_FUNC InterlockedCompareExchange(LONG volatile *Destination, LONG Exchan
}
void WIN_FUNC InitializeSListHead(PSLIST_HEADER ListHead) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("InitializeSListHead(%p)\n", ListHead);
if (!ListHead) {
return;

1
dll/kernel32/ioapiset.cpp
View File

@@ -7,6 +7,7 @@ namespace kernel32 {
BOOL WIN_FUNC GetOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred,
BOOL bWait) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetOverlappedResult(%p, %p, %p, %d)\n", hFile, lpOverlapped, lpNumberOfBytesTransferred, bWait);
(void)hFile;
if (!lpOverlapped) {

17
dll/kernel32/libloaderapi.cpp
View File

@@ -31,6 +31,7 @@ HRSRC findResourceInternal(HMODULE hModule, const wibo::ResourceIdentifier &type
namespace kernel32 {
BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("DisableThreadLibraryCalls(%p)\n", hLibModule);
if (!hLibModule) {
wibo::lastError = ERROR_INVALID_HANDLE;
@@ -50,6 +51,7 @@ BOOL WIN_FUNC DisableThreadLibraryCalls(HMODULE hLibModule) {
}
HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetModuleHandleA(%s)\n", lpModuleName);
const auto *module = wibo::findLoadedModule(lpModuleName);
if (!module) {
@@ -61,6 +63,7 @@ HMODULE WIN_FUNC GetModuleHandleA(LPCSTR lpModuleName) {
}
HMODULE WIN_FUNC GetModuleHandleW(LPCWSTR lpModuleName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetModuleHandleW -> ");
if (lpModuleName) {
const auto lpModuleNameA = wideStringToString(lpModuleName);
@@ -70,6 +73,7 @@ HMODULE WIN_FUNC GetModuleHandleW(LPCWSTR lpModuleName) {
}
DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetModuleFileNameA(%p, %p, %u)\n", hModule, lpFilename, nSize);
if (!lpFilename) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -106,6 +110,7 @@ DWORD WIN_FUNC GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize
}
DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetModuleFileNameW(%p, %s, %u)\n", hModule, wideStringToString(lpFilename).c_str(), nSize);
if (!lpFilename) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -147,6 +152,7 @@ DWORD WIN_FUNC GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSiz
}
HRSRC WIN_FUNC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindResourceA %p %p %p\n", hModule, lpName, lpType);
auto type = wibo::resourceIdentifierFromAnsi(lpType);
auto name = wibo::resourceIdentifierFromAnsi(lpName);
@@ -154,6 +160,7 @@ HRSRC WIN_FUNC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType) {
}
HRSRC WIN_FUNC FindResourceExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindResourceExA %p %p %p %u\n", hModule, lpName, lpType, wLanguage);
auto type = wibo::resourceIdentifierFromAnsi(lpType);
auto name = wibo::resourceIdentifierFromAnsi(lpName);
@@ -161,6 +168,7 @@ HRSRC WIN_FUNC FindResourceExA(HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WO
}
HRSRC WIN_FUNC FindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindResourceW %p\n", hModule);
auto type = wibo::resourceIdentifierFromWide(lpType);
auto name = wibo::resourceIdentifierFromWide(lpName);
@@ -168,6 +176,7 @@ HRSRC WIN_FUNC FindResourceW(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType) {
}
HRSRC WIN_FUNC FindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FindResourceExW %p %u\n", hModule, wLanguage);
auto type = wibo::resourceIdentifierFromWide(lpType);
auto name = wibo::resourceIdentifierFromWide(lpName);
@@ -175,6 +184,7 @@ HRSRC WIN_FUNC FindResourceExW(HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName,
}
HGLOBAL WIN_FUNC LoadResource(HMODULE hModule, HRSRC hResInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LoadResource %p %p\n", hModule, hResInfo);
if (!hResInfo) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
@@ -194,11 +204,13 @@ HGLOBAL WIN_FUNC LoadResource(HMODULE hModule, HRSRC hResInfo) {
}
LPVOID WIN_FUNC LockResource(HGLOBAL hResData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LockResource(%p)\n", hResData);
return hResData;
}
DWORD WIN_FUNC SizeofResource(HMODULE hModule, HRSRC hResInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SizeofResource(%p, %p)\n", hModule, hResInfo);
if (!hResInfo) {
wibo::lastError = ERROR_RESOURCE_DATA_NOT_FOUND;
@@ -218,6 +230,7 @@ DWORD WIN_FUNC SizeofResource(HMODULE hModule, HRSRC hResInfo) {
}
HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LoadLibraryA(%s)\n", lpLibFileName);
const auto *info = wibo::loadModule(lpLibFileName);
if (!info) {
@@ -229,6 +242,7 @@ HMODULE WIN_FUNC LoadLibraryA(LPCSTR lpLibFileName) {
}
HMODULE WIN_FUNC LoadLibraryW(LPCWSTR lpLibFileName) {
WIN_API_SEGMENT_GUARD();
if (!lpLibFileName) {
return nullptr;
}
@@ -238,6 +252,7 @@ HMODULE WIN_FUNC LoadLibraryW(LPCWSTR lpLibFileName) {
}
HMODULE WIN_FUNC LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags) {
WIN_API_SEGMENT_GUARD();
assert(!hFile);
DEBUG_LOG("LoadLibraryExW(%x) -> ", dwFlags);
auto filename = wideStringToString(lpLibFileName);
@@ -245,6 +260,7 @@ HMODULE WIN_FUNC LoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFla
}
BOOL WIN_FUNC FreeLibrary(HMODULE hLibModule) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FreeLibrary(%p)\n", hLibModule);
auto *info = wibo::moduleInfoFromHandle(hLibModule);
if (!info) {
@@ -256,6 +272,7 @@ BOOL WIN_FUNC FreeLibrary(HMODULE hLibModule) {
}
FARPROC WIN_FUNC GetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
WIN_API_SEGMENT_GUARD();
FARPROC result;
const auto info = wibo::moduleInfoFromHandle(hModule);
if (!info) {

11
dll/kernel32/memoryapi.cpp
View File

@@ -462,6 +462,7 @@ namespace kernel32 {
HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect,
DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateFileMappingA(%p, %p, %u, %u, %u, %s)\n", hFile, lpFileMappingAttributes, flProtect,
dwMaximumSizeHigh, dwMaximumSizeLow, lpName ? lpName : "(null)");
(void)lpFileMappingAttributes;
@@ -513,6 +514,7 @@ HANDLE WIN_FUNC CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMap
HANDLE WIN_FUNC CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect,
DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateFileMappingW -> ");
std::string name = wideStringToString(lpName);
return CreateFileMappingA(hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow,
@@ -659,6 +661,7 @@ static LPVOID mapViewOfFileInternal(Pin<MappingObject> mapping, DWORD dwDesiredA
LPVOID WIN_FUNC MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("MapViewOfFile(%p, 0x%x, %u, %u, %zu)\n", hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh,
dwFileOffsetLow, dwNumberOfBytesToMap);
@@ -673,6 +676,7 @@ LPVOID WIN_FUNC MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess,
LPVOID WIN_FUNC MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap, LPVOID lpBaseAddress) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("MapViewOfFileEx(%p, 0x%x, %u, %u, %zu, %p)\n", hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh,
dwFileOffsetLow, dwNumberOfBytesToMap, lpBaseAddress);
@@ -686,6 +690,7 @@ LPVOID WIN_FUNC MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess
}
BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("UnmapViewOfFile(%p)\n", lpBaseAddress);
std::unique_lock lk(g_viewInfoMutex);
auto it = g_viewInfo.find(reinterpret_cast<uintptr_t>(lpBaseAddress));
@@ -705,6 +710,7 @@ BOOL WIN_FUNC UnmapViewOfFile(LPCVOID lpBaseAddress) {
}
LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("VirtualAlloc(%p, %zu, %u, %u)\n", lpAddress, dwSize, flAllocationType, flProtect);
if (dwSize == 0) {
@@ -894,6 +900,7 @@ LPVOID WIN_FUNC VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocation
}
BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("VirtualFree(%p, %zu, %u)\n", lpAddress, dwSize, dwFreeType);
if (!lpAddress) {
wibo::lastError = ERROR_INVALID_ADDRESS;
@@ -986,6 +993,7 @@ BOOL WIN_FUNC VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType) {
}
BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("VirtualProtect(%p, %zu, %u)\n", lpAddress, dwSize, flNewProtect);
if (!lpAddress || dwSize == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1045,6 +1053,7 @@ BOOL WIN_FUNC VirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect
}
SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("VirtualQuery(%p, %p, %zu)\n", lpAddress, lpBuffer, dwLength);
if (!lpBuffer || dwLength < sizeof(MEMORY_BASIC_INFORMATION)) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -1086,6 +1095,7 @@ SIZE_T WIN_FUNC VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuff
BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorkingSetSize,
PSIZE_T lpMaximumWorkingSetSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetProcessWorkingSetSize(%p, %p, %p)\n", hProcess, lpMinimumWorkingSetSize, lpMaximumWorkingSetSize);
(void)hProcess;
if (!lpMinimumWorkingSetSize || !lpMaximumWorkingSetSize) {
@@ -1100,6 +1110,7 @@ BOOL WIN_FUNC GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T lpMinimumWorking
BOOL WIN_FUNC SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T dwMinimumWorkingSetSize,
SIZE_T dwMaximumWorkingSetSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetProcessWorkingSetSize(%p, %zu, %zu)\n", hProcess, dwMinimumWorkingSetSize, dwMaximumWorkingSetSize);
(void)hProcess;
(void)dwMinimumWorkingSetSize;

1
dll/kernel32/namedpipeapi.cpp
View File

@@ -35,6 +35,7 @@ void configureInheritability(int fd, bool inherit) {
} // namespace
BOOL WIN_FUNC CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreatePipe(%p, %p, %p, %u)\n", hReadPipe, hWritePipe, lpPipeAttributes, nSize);
if (!hReadPipe || !hWritePipe) {
wibo::lastError = ERROR_INVALID_PARAMETER;

12
dll/kernel32/processenv.cpp
View File

@@ -41,28 +41,33 @@ std::string convertEnvValueToHost(const std::string &name, const char *rawValue)
namespace kernel32 {
LPSTR WIN_FUNC GetCommandLineA() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCommandLineA() -> %s\n", wibo::commandLine.c_str());
wibo::lastError = ERROR_SUCCESS;
return const_cast<LPSTR>(wibo::commandLine.c_str());
}
LPWSTR WIN_FUNC GetCommandLineW() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCommandLineW() -> %s\n", wideStringToString(wibo::commandLineW.data()).c_str());
wibo::lastError = ERROR_SUCCESS;
return wibo::commandLineW.data();
}
HANDLE WIN_FUNC GetStdHandle(DWORD nStdHandle) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetStdHandle(%d)\n", nStdHandle);
return files::getStdHandle(nStdHandle);
}
BOOL WIN_FUNC SetStdHandle(DWORD nStdHandle, HANDLE hHandle) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetStdHandle(%d, %p)\n", nStdHandle, hHandle);
return files::setStdHandle(nStdHandle, hHandle);
}
LPCH WIN_FUNC GetEnvironmentStrings() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetEnvironmentStrings()\n");
size_t bufSize = 0;
@@ -96,6 +101,7 @@ LPCH WIN_FUNC GetEnvironmentStrings() {
}
LPWCH WIN_FUNC GetEnvironmentStringsW() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetEnvironmentStringsW()\n");
size_t bufSizeW = 0;
@@ -131,6 +137,7 @@ LPWCH WIN_FUNC GetEnvironmentStringsW() {
}
BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FreeEnvironmentStringsA(%p)\n", penv);
if (!penv) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -142,6 +149,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsA(LPCH penv) {
}
BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FreeEnvironmentStringsW(%p)\n", penv);
if (!penv) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -153,6 +161,7 @@ BOOL WIN_FUNC FreeEnvironmentStringsW(LPWCH penv) {
}
DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetEnvironmentVariableA(%s, %p, %u)\n", lpName ? lpName : "(null)", lpBuffer, nSize);
if (!lpName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -184,6 +193,7 @@ DWORD WIN_FUNC GetEnvironmentVariableA(LPCSTR lpName, LPSTR lpBuffer, DWORD nSiz
}
DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
std::string name = lpName ? wideStringToString(lpName) : std::string();
DEBUG_LOG("GetEnvironmentVariableW(%s, %p, %u)\n", name.c_str(), lpBuffer, nSize);
if (name.empty()) {
@@ -217,6 +227,7 @@ DWORD WIN_FUNC GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer, DWORD nS
}
BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetEnvironmentVariableA(%s, %s)\n", lpName ? lpName : "(null)", lpValue ? lpValue : "(null)");
if (!lpName || std::strchr(lpName, '=')) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -244,6 +255,7 @@ BOOL WIN_FUNC SetEnvironmentVariableA(LPCSTR lpName, LPCSTR lpValue) {
}
BOOL WIN_FUNC SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetEnvironmentVariableW -> ");
if (!lpName) {
wibo::lastError = ERROR_INVALID_PARAMETER;

38
dll/kernel32/processthreadsapi.cpp
View File

@@ -124,14 +124,19 @@ void *threadTrampoline(void *param) {
// Install TIB
TIB *threadTib = nullptr;
uint16_t previousSegment = 0;
uint16_t previousFs = 0;
uint16_t previousGs = 0;
if (wibo::tibSelector) {
asm volatile("mov %%fs, %0" : "=r"(previousSegment));
asm volatile("mov %%fs, %0" : "=r"(previousFs));
asm volatile("mov %%gs, %0" : "=r"(previousGs));
threadTib = wibo::allocateTib();
if (threadTib) {
wibo::initializeTibStackInfo(threadTib);
if (wibo::installTibForCurrentThread(threadTib)) {
asm volatile("movw %0, %%fs" : : "r"(wibo::tibSelector) : "memory");
threadTib->hostFsSelector = previousFs;
threadTib->hostGsSelector = previousGs;
threadTib->hostSegmentsValid = 1;
} else {
fprintf(stderr, "!!! Failed to install TIB for new thread\n");
wibo::destroyTib(threadTib);
@@ -172,6 +177,7 @@ inline bool isPseudoCurrentThreadHandle(HANDLE h) {
namespace kernel32 {
BOOL WIN_FUNC IsProcessorFeaturePresent(DWORD ProcessorFeature) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsProcessorFeaturePresent(%u)\n", ProcessorFeature);
if (ProcessorFeature == 0) { // PF_FLOATING_POINT_PRECISION_ERRATA
return TRUE;
@@ -187,17 +193,20 @@ BOOL WIN_FUNC IsProcessorFeaturePresent(DWORD ProcessorFeature) {
}
HANDLE WIN_FUNC GetCurrentProcess() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCurrentProcess() -> %p\n", reinterpret_cast<void *>(static_cast<uintptr_t>(-1)));
return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(-1));
}
DWORD WIN_FUNC GetCurrentProcessId() {
WIN_API_SEGMENT_GUARD();
DWORD pid = static_cast<DWORD>(getpid());
DEBUG_LOG("GetCurrentProcessId() -> %u\n", pid);
return pid;
}
DWORD WIN_FUNC GetCurrentThreadId() {
WIN_API_SEGMENT_GUARD();
pthread_t thread = pthread_self();
const auto threadId = static_cast<DWORD>(thread);
DEBUG_LOG("GetCurrentThreadId() -> %u\n", threadId);
@@ -205,6 +214,7 @@ DWORD WIN_FUNC GetCurrentThreadId() {
}
HANDLE WIN_FUNC GetCurrentThread() {
WIN_API_SEGMENT_GUARD();
HANDLE pseudoHandle = reinterpret_cast<HANDLE>(kPseudoCurrentThreadHandleValue);
DEBUG_LOG("GetCurrentThread() -> %p\n", pseudoHandle);
return pseudoHandle;
@@ -212,6 +222,7 @@ HANDLE WIN_FUNC GetCurrentThread() {
BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffinityMask,
PDWORD_PTR lpSystemAffinityMask) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetProcessAffinityMask(%p, %p, %p)\n", hProcess, lpProcessAffinityMask, lpSystemAffinityMask);
if (!lpProcessAffinityMask || !lpSystemAffinityMask) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -245,6 +256,7 @@ BOOL WIN_FUNC GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR lpProcessAffini
}
BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinityMask) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetProcessAffinityMask(%p, 0x%lx)\n", hProcess, static_cast<unsigned long>(dwProcessAffinityMask));
if (dwProcessAffinityMask == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -274,6 +286,7 @@ BOOL WIN_FUNC SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinit
}
DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetThreadAffinityMask(%p, 0x%lx)\n", hThread, static_cast<unsigned long>(dwThreadAffinityMask));
if (dwThreadAffinityMask == 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -303,11 +316,13 @@ DWORD_PTR WIN_FUNC SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffin
}
void WIN_FUNC ExitProcess(UINT uExitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ExitProcess(%u)\n", uExitCode);
exit(static_cast<int>(uExitCode));
}
BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("TerminateProcess(%p, %u)\n", hProcess, uExitCode);
if (hProcess == reinterpret_cast<HANDLE>(static_cast<uintptr_t>(-1))) {
exit(static_cast<int>(uExitCode));
@@ -343,6 +358,7 @@ BOOL WIN_FUNC TerminateProcess(HANDLE hProcess, UINT uExitCode) {
}
BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetExitCodeProcess(%p, %p)\n", hProcess, lpExitCode);
if (!lpExitCode) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -364,6 +380,7 @@ BOOL WIN_FUNC GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode) {
}
DWORD WIN_FUNC TlsAlloc() {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("TlsAlloc()\n");
for (DWORD i = 0; i < kMaxTlsValues; ++i) {
if (!g_tlsSlotsUsed[i]) {
@@ -378,6 +395,7 @@ DWORD WIN_FUNC TlsAlloc() {
}
BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("TlsFree(%u)\n", dwTlsIndex);
if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -390,6 +408,7 @@ BOOL WIN_FUNC TlsFree(DWORD dwTlsIndex) {
}
LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("TlsGetValue(%u)\n", dwTlsIndex);
if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -400,6 +419,7 @@ LPVOID WIN_FUNC TlsGetValue(DWORD dwTlsIndex) {
}
BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("TlsSetValue(%u, %p)\n", dwTlsIndex, lpTlsValue);
if (dwTlsIndex >= kMaxTlsValues || !g_tlsSlotsUsed[dwTlsIndex]) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -411,6 +431,7 @@ BOOL WIN_FUNC TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) {
}
DWORD WIN_FUNC ResumeThread(HANDLE hThread) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ResumeThread(%p)\n", hThread);
// TODO: behavior with current thread handle?
auto obj = wibo::handles().getAs<ThreadObject>(hThread);
@@ -438,6 +459,7 @@ DWORD WIN_FUNC ResumeThread(HANDLE hThread) {
}
HRESULT WIN_FUNC SetThreadDescription(HANDLE hThread, LPCWSTR lpThreadDescription) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetThreadDescription(%p, %p)\n", hThread, lpThreadDescription);
(void)hThread;
(void)lpThreadDescription;
@@ -447,6 +469,7 @@ HRESULT WIN_FUNC SetThreadDescription(HANDLE hThread, LPCWSTR lpThreadDescriptio
HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags,
LPDWORD lpThreadId) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateThread(%p, %zu, %p, %p, %u, %p)\n", lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter,
dwCreationFlags, lpThreadId);
(void)lpThreadAttributes;
@@ -494,6 +517,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw
}
[[noreturn]] void WIN_FUNC ExitThread(DWORD dwExitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ExitThread(%u)\n", dwExitCode);
ThreadObject *obj = g_currentThreadObject;
{
@@ -507,6 +531,7 @@ HANDLE WIN_FUNC CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dw
}
BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetExitCodeThread(%p, %p)\n", hThread, lpExitCode);
if (!lpExitCode) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -529,6 +554,7 @@ BOOL WIN_FUNC GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) {
}
BOOL WIN_FUNC SetThreadPriority(HANDLE hThread, int nPriority) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetThreadPriority(%p, %d)\n", hThread, nPriority);
(void)hThread;
(void)nPriority;
@@ -537,6 +563,7 @@ BOOL WIN_FUNC SetThreadPriority(HANDLE hThread, int nPriority) {
}
int WIN_FUNC GetThreadPriority(HANDLE hThread) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetThreadPriority(%p)\n", hThread);
(void)hThread;
wibo::lastError = ERROR_SUCCESS;
@@ -544,6 +571,7 @@ int WIN_FUNC GetThreadPriority(HANDLE hThread) {
}
DWORD WIN_FUNC GetPriorityClass(HANDLE hProcess) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetPriorityClass(%p)\n", hProcess);
(void)hProcess;
wibo::lastError = ERROR_SUCCESS;
@@ -552,6 +580,7 @@ DWORD WIN_FUNC GetPriorityClass(HANDLE hProcess) {
BOOL WIN_FUNC GetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime, FILETIME *lpExitTime, FILETIME *lpKernelTime,
FILETIME *lpUserTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetThreadTimes(%p, %p, %p, %p, %p)\n", hThread, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime);
if (!lpKernelTime || !lpUserTime) {
@@ -601,6 +630,7 @@ BOOL WIN_FUNC CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSE
LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags,
LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateProcessA %s \"%s\" %p %p %d 0x%x %p %s %p %p\n", lpApplicationName ? lpApplicationName : "<null>",
lpCommandLine ? lpCommandLine : "<null>", lpProcessAttributes, lpThreadAttributes, bInheritHandles,
dwCreationFlags, lpEnvironment, lpCurrentDirectory ? lpCurrentDirectory : "<none>", lpStartupInfo,
@@ -655,6 +685,7 @@ BOOL WIN_FUNC CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LP
LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags,
LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation) {
WIN_API_SEGMENT_GUARD();
std::string applicationUtf8;
if (lpApplicationName) {
applicationUtf8 = wideStringToString(lpApplicationName);
@@ -686,16 +717,19 @@ BOOL WIN_FUNC CreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LP
}
void WIN_FUNC GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetStartupInfoA(%p)\n", lpStartupInfo);
populateStartupInfo(lpStartupInfo);
}
void WIN_FUNC GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetStartupInfoW(%p)\n", lpStartupInfo);
populateStartupInfo(lpStartupInfo);
}
BOOL WIN_FUNC SetThreadStackGuarantee(PULONG StackSizeInBytes) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetThreadStackGuarantee(%p)\n", StackSizeInBytes);
(void)StackSizeInBytes;
return TRUE;

2
dll/kernel32/profileapi.cpp
View File

@@ -5,6 +5,7 @@
namespace kernel32 {
BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: QueryPerformanceCounter(%p)\n", lpPerformanceCount);
if (!lpPerformanceCount) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -16,6 +17,7 @@ BOOL WIN_FUNC QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) {
}
BOOL WIN_FUNC QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: QueryPerformanceFrequency(%p)\n", lpFrequency);
if (!lpFrequency) {
wibo::lastError = ERROR_INVALID_PARAMETER;

4
dll/kernel32/stringapiset.cpp
View File

@@ -12,6 +12,7 @@ namespace kernel32 {
int WIN_FUNC WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideCharStr, int cchWideChar,
LPSTR lpMultiByteStr, int cbMultiByte, LPCCH lpDefaultChar, LPBOOL lpUsedDefaultChar) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("WideCharToMultiByte(%u, %u, %p, %d, %p, %d, %p, %p)\n", CodePage, dwFlags, lpWideCharStr, cchWideChar,
lpMultiByteStr, cbMultiByte, lpDefaultChar, lpUsedDefaultChar);
@@ -43,6 +44,7 @@ int WIN_FUNC WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideChar
int WIN_FUNC MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByteStr, int cbMultiByte,
LPWSTR lpWideCharStr, int cchWideChar) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("MultiByteToWideChar(%u, %u, %d, %d)\n", CodePage, dwFlags, cbMultiByte, cchWideChar);
(void)CodePage;
@@ -68,6 +70,7 @@ int WIN_FUNC MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByte
}
BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWORD lpCharType) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetStringTypeW(%u, %p, %i, %p)\n", dwInfoType, lpSrcStr, cchSrc, lpCharType);
assert(dwInfoType == 1); // CT_CTYPE1
@@ -101,6 +104,7 @@ BOOL WIN_FUNC GetStringTypeW(DWORD dwInfoType, LPCWCH lpSrcStr, int cchSrc, LPWO
}
BOOL WIN_FUNC GetStringTypeA(LCID Locale, DWORD dwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetStringTypeA(%u, %u, %p, %d, %p)\n", Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType);
(void)Locale;

41
dll/kernel32/synchapi.cpp
View File

@@ -38,11 +38,13 @@ void makeWideNameFromAnsi(LPCSTR ansiName, std::vector<uint16_t> &outWide) {
namespace kernel32 {
void WIN_FUNC Sleep(DWORD dwMilliseconds) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("Sleep(%u)\n", dwMilliseconds);
usleep(static_cast<useconds_t>(dwMilliseconds) * 1000);
}
HANDLE WIN_FUNC CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateMutexW(%p, %d, %s)\n", lpMutexAttributes, static_cast<int>(bInitialOwner),
wideStringToString(lpName).c_str());
std::u16string name = makeU16String(lpName);
@@ -73,6 +75,7 @@ HANDLE WIN_FUNC CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInit
}
HANDLE WIN_FUNC CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateMutexA -> ");
std::vector<uint16_t> wideName;
makeWideNameFromAnsi(lpName, wideName);
@@ -81,6 +84,7 @@ HANDLE WIN_FUNC CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInit
}
BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ReleaseMutex(%p)\n", hMutex);
auto mu = wibo::handles().getAs<MutexObject>(hMutex);
if (!mu) {
@@ -110,6 +114,7 @@ BOOL WIN_FUNC ReleaseMutex(HANDLE hMutex) {
HANDLE WIN_FUNC CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState,
LPCWSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateEventW(%p, %d, %d, %s)\n", lpEventAttributes, static_cast<int>(bManualReset),
static_cast<int>(bInitialState), wideStringToString(lpName).c_str());
std::u16string name = makeU16String(lpName);
@@ -136,6 +141,7 @@ HANDLE WIN_FUNC CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManu
HANDLE WIN_FUNC CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState,
LPCSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateEventA -> ");
std::vector<uint16_t> wideName;
makeWideNameFromAnsi(lpName, wideName);
@@ -145,6 +151,7 @@ HANDLE WIN_FUNC CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManu
HANDLE WIN_FUNC CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount,
LPCWSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateSemaphoreW(%p, %ld, %ld, %s)\n", lpSemaphoreAttributes, lInitialCount, lMaximumCount,
wideStringToString(lpName).c_str());
auto name = makeU16String(lpName);
@@ -171,6 +178,7 @@ HANDLE WIN_FUNC CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LO
HANDLE WIN_FUNC CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount,
LPCSTR lpName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CreateSemaphoreA -> ");
std::vector<uint16_t> wideName;
makeWideNameFromAnsi(lpName, wideName);
@@ -179,6 +187,7 @@ HANDLE WIN_FUNC CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LO
}
BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPreviousCount) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ReleaseSemaphore(%p, %ld, %p)\n", hSemaphore, lReleaseCount, lpPreviousCount);
if (lReleaseCount <= 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -215,6 +224,7 @@ BOOL WIN_FUNC ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, PLONG lpPr
}
BOOL WIN_FUNC SetEvent(HANDLE hEvent) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetEvent(%p)\n", hEvent);
auto ev = wibo::handles().getAs<EventObject>(hEvent);
if (!ev) {
@@ -227,6 +237,7 @@ BOOL WIN_FUNC SetEvent(HANDLE hEvent) {
}
BOOL WIN_FUNC ResetEvent(HANDLE hEvent) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("ResetEvent(%p)\n", hEvent);
auto ev = wibo::handles().getAs<EventObject>(hEvent);
if (!ev) {
@@ -239,6 +250,7 @@ BOOL WIN_FUNC ResetEvent(HANDLE hEvent) {
}
DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("WaitForSingleObject(%p, %u)\n", hHandle, dwMilliseconds);
HandleMeta meta{};
Pin<> obj = wibo::handles().get(hHandle, &meta);
@@ -346,6 +358,7 @@ DWORD WIN_FUNC WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) {
}
void WIN_FUNC InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: InitializeCriticalSection(%p)\n", lpCriticalSection);
if (!lpCriticalSection) {
return;
@@ -354,6 +367,7 @@ void WIN_FUNC InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection) {
}
BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount, DWORD Flags) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: InitializeCriticalSectionEx(%p, %u, 0x%x)\n", lpCriticalSection, dwSpinCount, Flags);
if (!lpCriticalSection) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -370,6 +384,7 @@ BOOL WIN_FUNC InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,
}
BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: InitializeCriticalSectionAndSpinCount(%p, %u)\n", lpCriticalSection, dwSpinCount);
if (!lpCriticalSection) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -382,21 +397,25 @@ BOOL WIN_FUNC InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCritica
}
void WIN_FUNC DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: DeleteCriticalSection(%p)\n", lpCriticalSection);
(void)lpCriticalSection;
}
void WIN_FUNC EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: EnterCriticalSection(%p)\n", lpCriticalSection);
(void)lpCriticalSection;
}
void WIN_FUNC LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: LeaveCriticalSection(%p)\n", lpCriticalSection);
(void)lpCriticalSection;
}
BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBOOL fPending, LPVOID *lpContext) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: InitOnceBeginInitialize(%p, %u, %p, %p)\n", lpInitOnce, dwFlags, fPending, lpContext);
if (!lpInitOnce) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -417,6 +436,7 @@ BOOL WIN_FUNC InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags, PBO
}
BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: InitOnceComplete(%p, %u, %p)\n", lpInitOnce, dwFlags, lpContext);
if (!lpInitOnce) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -431,15 +451,28 @@ BOOL WIN_FUNC InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpC
return TRUE;
}
void WIN_FUNC AcquireSRWLockShared(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: AcquireSRWLockShared(%p)\n", SRWLock); }
void WIN_FUNC AcquireSRWLockShared(PSRWLOCK SRWLock) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: AcquireSRWLockShared(%p)\n", SRWLock);
}
void WIN_FUNC ReleaseSRWLockShared(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: ReleaseSRWLockShared(%p)\n", SRWLock); }
void WIN_FUNC ReleaseSRWLockShared(PSRWLOCK SRWLock) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: ReleaseSRWLockShared(%p)\n", SRWLock);
}
void WIN_FUNC AcquireSRWLockExclusive(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: AcquireSRWLockExclusive(%p)\n", SRWLock); }
void WIN_FUNC AcquireSRWLockExclusive(PSRWLOCK SRWLock) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: AcquireSRWLockExclusive(%p)\n", SRWLock);
}
void WIN_FUNC ReleaseSRWLockExclusive(PSRWLOCK SRWLock) { VERBOSE_LOG("STUB: ReleaseSRWLockExclusive(%p)\n", SRWLock); }
void WIN_FUNC ReleaseSRWLockExclusive(PSRWLOCK SRWLock) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: ReleaseSRWLockExclusive(%p)\n", SRWLock);
}
BOOLEAN WIN_FUNC TryAcquireSRWLockExclusive(PSRWLOCK SRWLock) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("STUB: TryAcquireSRWLockExclusive(%p)\n", SRWLock);
return TRUE;
}

7
dll/kernel32/sysinfoapi.cpp
View File

@@ -31,6 +31,7 @@ DWORD_PTR computeSystemProcessorMask(unsigned int cpuCount) {
namespace kernel32 {
void WIN_FUNC GetSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemInfo(%p)\n", lpSystemInfo);
if (!lpSystemInfo) {
return;
@@ -67,6 +68,7 @@ void WIN_FUNC GetSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
}
void WIN_FUNC GetSystemTime(LPSYSTEMTIME lpSystemTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemTime(%p)\n", lpSystemTime);
if (!lpSystemTime) {
return;
@@ -95,6 +97,7 @@ void WIN_FUNC GetSystemTime(LPSYSTEMTIME lpSystemTime) {
}
void WIN_FUNC GetLocalTime(LPSYSTEMTIME lpSystemTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLocalTime(%p)\n", lpSystemTime);
if (!lpSystemTime) {
return;
@@ -123,6 +126,7 @@ void WIN_FUNC GetLocalTime(LPSYSTEMTIME lpSystemTime) {
}
void WIN_FUNC GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemTimeAsFileTime(%p)\n", lpSystemTimeAsFileTime);
if (!lpSystemTimeAsFileTime) {
return;
@@ -154,6 +158,7 @@ void WIN_FUNC GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime) {
}
DWORD WIN_FUNC GetTickCount() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetTickCount()\n");
#if defined(CLOCK_MONOTONIC)
struct timespec ts{};
@@ -178,11 +183,13 @@ DWORD WIN_FUNC GetTickCount() {
}
DWORD WIN_FUNC GetVersion() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetVersion()\n");
return kMajorVersion | (kMinorVersion << 8) | (5 << 16) | (kBuildNumber << 24);
}
BOOL WIN_FUNC GetVersionExA(LPOSVERSIONINFOA lpVersionInformation) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetVersionExA(%p)\n", lpVersionInformation);
if (!lpVersionInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;

7
dll/kernel32/timezoneapi.cpp
View File

@@ -10,6 +10,7 @@
namespace kernel32 {
BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SystemTimeToFileTime(%p, %p)\n", lpSystemTime, lpFileTime);
if (!lpSystemTime || !lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -36,6 +37,7 @@ BOOL WIN_FUNC SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lp
}
BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FileTimeToSystemTime(%p, %p)\n", lpFileTime, lpSystemTime);
if (!lpFileTime || !lpSystemTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -65,6 +67,7 @@ BOOL WIN_FUNC FileTimeToSystemTime(const FILETIME *lpFileTime, LPSYSTEMTIME lpSy
}
BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpLocalFileTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FileTimeToLocalFileTime(%p, %p)\n", lpFileTime, lpLocalFileTime);
if (!lpFileTime || !lpLocalFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -114,6 +117,7 @@ BOOL WIN_FUNC FileTimeToLocalFileTime(const FILETIME *lpFileTime, LPFILETIME lpL
}
BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIME lpFileTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LocalFileTimeToFileTime(%p, %p)\n", lpLocalFileTime, lpFileTime);
if (!lpLocalFileTime || !lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -156,6 +160,7 @@ BOOL WIN_FUNC LocalFileTimeToFileTime(const FILETIME *lpLocalFileTime, LPFILETIM
}
BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("DosDateTimeToFileTime(%04x, %04x, %p)\n", wFatDate, wFatTime, lpFileTime);
if (!lpFileTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -191,6 +196,7 @@ BOOL WIN_FUNC DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, LPFILETIME lpF
}
BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FileTimeToDosDateTime(%p, %p, %p)\n", lpFileTime, lpFatDate, lpFatTime);
if (!lpFileTime || !lpFatDate || !lpFatTime) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -220,6 +226,7 @@ BOOL WIN_FUNC FileTimeToDosDateTime(const FILETIME *lpFileTime, LPWORD lpFatDate
}
DWORD WIN_FUNC GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetTimeZoneInformation(%p)\n", lpTimeZoneInformation);
if (!lpTimeZoneInformation) {
wibo::lastError = ERROR_INVALID_PARAMETER;

42
dll/kernel32/winbase.cpp
View File

@@ -303,6 +303,7 @@ const uint16_t kComputerNameWide[] = {u'C', u'O', u'M', u'P', u'N', u'A', u'M',
namespace kernel32 {
ATOM WIN_FUNC AddAtomA(LPCSTR lpString) {
WIN_API_SEGMENT_GUARD();
ATOM atom = 0;
if (tryHandleIntegerAtomPointer(lpString, atom)) {
DEBUG_LOG("AddAtomA(int:%u)\n", atom);
@@ -325,6 +326,7 @@ ATOM WIN_FUNC AddAtomA(LPCSTR lpString) {
}
ATOM WIN_FUNC AddAtomW(LPCWSTR lpString) {
WIN_API_SEGMENT_GUARD();
ATOM atom = 0;
if (tryHandleIntegerAtomPointer(lpString, atom)) {
DEBUG_LOG("AddAtomW(int:%u)\n", atom);
@@ -349,6 +351,7 @@ ATOM WIN_FUNC AddAtomW(LPCWSTR lpString) {
}
ATOM WIN_FUNC FindAtomA(LPCSTR lpString) {
WIN_API_SEGMENT_GUARD();
ATOM atom = 0;
if (tryHandleIntegerAtomPointer(lpString, atom)) {
DEBUG_LOG("FindAtomA(int:%u)\n", atom);
@@ -371,6 +374,7 @@ ATOM WIN_FUNC FindAtomA(LPCSTR lpString) {
}
ATOM WIN_FUNC FindAtomW(LPCWSTR lpString) {
WIN_API_SEGMENT_GUARD();
ATOM atom = 0;
if (tryHandleIntegerAtomPointer(lpString, atom)) {
DEBUG_LOG("FindAtomW(int:%u)\n", atom);
@@ -395,6 +399,7 @@ ATOM WIN_FUNC FindAtomW(LPCWSTR lpString) {
}
UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetAtomNameA(%u, %p, %d)\n", nAtom, lpBuffer, nSize);
if (!lpBuffer || nSize <= 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -427,6 +432,7 @@ UINT WIN_FUNC GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize) {
}
UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetAtomNameW(%u, %p, %d)\n", nAtom, lpBuffer, nSize);
if (!lpBuffer || nSize <= 0) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -463,6 +469,7 @@ UINT WIN_FUNC GetAtomNameW(ATOM nAtom, LPWSTR lpBuffer, int nSize) {
}
UINT WIN_FUNC SetHandleCount(UINT uNumber) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetHandleCount(%u)\n", uNumber);
(void)uNumber;
return 0x3FFE;
@@ -470,6 +477,7 @@ UINT WIN_FUNC SetHandleCount(UINT uNumber) {
DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer,
DWORD nSize, va_list *Arguments) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("FormatMessageA(%u, %p, %u, %u, %p, %u, %p)\n", dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer,
nSize, Arguments);
@@ -514,16 +522,19 @@ DWORD WIN_FUNC FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId
}
PVOID WIN_FUNC EncodePointer(PVOID Ptr) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("EncodePointer(%p)\n", Ptr);
return Ptr;
}
PVOID WIN_FUNC DecodePointer(PVOID Ptr) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("DecodePointer(%p)\n", Ptr);
return Ptr;
}
BOOL WIN_FUNC SetDllDirectoryA(LPCSTR lpPathName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetDllDirectoryA(%s)\n", lpPathName);
if (!lpPathName || lpPathName[0] == '\0') {
wibo::clearDllDirectoryOverride();
@@ -565,6 +576,7 @@ void tryMarkExecutable(void *mem) {
}
BOOL WIN_FUNC IsBadReadPtr(LPCVOID lp, UINT_PTR ucb) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: IsBadReadPtr(ptr=%p, size=%zu)\n", lp, static_cast<size_t>(ucb));
if (!lp) {
return TRUE;
@@ -573,6 +585,7 @@ BOOL WIN_FUNC IsBadReadPtr(LPCVOID lp, UINT_PTR ucb) {
}
BOOL WIN_FUNC IsBadWritePtr(LPVOID lp, UINT_PTR ucb) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: IsBadWritePtr(ptr=%p, size=%zu)\n", lp, static_cast<size_t>(ucb));
if (!lp && ucb != 0) {
return TRUE;
@@ -581,6 +594,7 @@ BOOL WIN_FUNC IsBadWritePtr(LPVOID lp, UINT_PTR ucb) {
}
BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetComputerNameA(%p, %p)\n", lpBuffer, nSize);
if (!nSize || !lpBuffer) {
if (nSize) {
@@ -603,6 +617,7 @@ BOOL WIN_FUNC GetComputerNameA(LPSTR lpBuffer, LPDWORD nSize) {
}
BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetComputerNameW(%p, %p)\n", lpBuffer, nSize);
if (!nSize || !lpBuffer) {
if (nSize) {
@@ -625,6 +640,7 @@ BOOL WIN_FUNC GetComputerNameW(LPWSTR lpBuffer, LPDWORD nSize) {
}
HGLOBAL WIN_FUNC GlobalAlloc(UINT uFlags, SIZE_T dwBytes) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("GlobalAlloc(%x, %zu)\n", uFlags, static_cast<size_t>(dwBytes));
if (uFlags & GMEM_MOVEABLE) {
// not implemented rn
@@ -636,12 +652,14 @@ HGLOBAL WIN_FUNC GlobalAlloc(UINT uFlags, SIZE_T dwBytes) {
}
HGLOBAL WIN_FUNC GlobalFree(HGLOBAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("GlobalFree(%p)\n", hMem);
std::free(hMem);
return nullptr;
}
HGLOBAL WIN_FUNC GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("GlobalReAlloc(%p, %zu, %x)\n", hMem, static_cast<size_t>(dwBytes), uFlags);
if (uFlags & GMEM_MODIFY) {
assert(0);
@@ -652,12 +670,14 @@ HGLOBAL WIN_FUNC GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags) {
}
UINT WIN_FUNC GlobalFlags(HGLOBAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("GlobalFlags(%p)\n", hMem);
(void)hMem;
return 0;
}
HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalAlloc(%x, %zu)\n", uFlags, static_cast<size_t>(uBytes));
bool zero = (uFlags & LMEM_ZEROINIT) != 0;
if ((uFlags & LMEM_MOVEABLE) != 0) {
@@ -676,6 +696,7 @@ HLOCAL WIN_FUNC LocalAlloc(UINT uFlags, SIZE_T uBytes) {
}
HLOCAL WIN_FUNC LocalFree(HLOCAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalFree(%p)\n", hMem);
// Windows returns NULL on success.
std::free(hMem);
@@ -684,6 +705,7 @@ HLOCAL WIN_FUNC LocalFree(HLOCAL hMem) {
}
HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalReAlloc(%p, %zu, %x)\n", hMem, static_cast<size_t>(uBytes), uFlags);
bool zero = (uFlags & LMEM_ZEROINIT) != 0;
if ((uFlags & LMEM_MOVEABLE) != 0) {
@@ -702,17 +724,20 @@ HLOCAL WIN_FUNC LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags) {
}
HLOCAL WIN_FUNC LocalHandle(LPCVOID pMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalHandle(%p)\n", pMem);
return const_cast<LPVOID>(pMem);
}
LPVOID WIN_FUNC LocalLock(HLOCAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalLock(%p)\n", hMem);
wibo::lastError = ERROR_SUCCESS;
return hMem;
}
BOOL WIN_FUNC LocalUnlock(HLOCAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalUnlock(%p)\n", hMem);
(void)hMem;
wibo::lastError = ERROR_SUCCESS;
@@ -720,11 +745,13 @@ BOOL WIN_FUNC LocalUnlock(HLOCAL hMem) {
}
SIZE_T WIN_FUNC LocalSize(HLOCAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalSize(%p)\n", hMem);
return hMem ? mi_usable_size(hMem) : 0;
}
UINT WIN_FUNC LocalFlags(HLOCAL hMem) {
WIN_API_SEGMENT_GUARD();
VERBOSE_LOG("LocalFlags(%p)\n", hMem);
(void)hMem;
return 0;
@@ -733,6 +760,7 @@ UINT WIN_FUNC LocalFlags(HLOCAL hMem) {
static constexpr const char *kSystemDirectoryA = "C:\\Windows\\System32";
UINT WIN_FUNC GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemDirectoryA(%p, %u)\n", lpBuffer, uSize);
if (!lpBuffer) {
return 0;
@@ -747,6 +775,7 @@ UINT WIN_FUNC GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize) {
}
UINT WIN_FUNC GetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemDirectoryW(%p, %u)\n", lpBuffer, uSize);
if (!lpBuffer) {
return 0;
@@ -762,6 +791,7 @@ UINT WIN_FUNC GetSystemDirectoryW(LPWSTR lpBuffer, UINT uSize) {
}
UINT WIN_FUNC GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemWow64DirectoryA(%p, %u)\n", lpBuffer, uSize);
(void)lpBuffer;
(void)uSize;
@@ -770,6 +800,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryA(LPSTR lpBuffer, UINT uSize) {
}
UINT WIN_FUNC GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetSystemWow64DirectoryW(%p, %u)\n", lpBuffer, uSize);
(void)lpBuffer;
(void)uSize;
@@ -778,6 +809,7 @@ UINT WIN_FUNC GetSystemWow64DirectoryW(LPWSTR lpBuffer, UINT uSize) {
}
UINT WIN_FUNC GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetWindowsDirectoryA(%p, %u)\n", lpBuffer, uSize);
if (!lpBuffer) {
return 0;
@@ -793,6 +825,7 @@ UINT WIN_FUNC GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize) {
}
DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCurrentDirectoryA(%u, %p)\n", nBufferLength, lpBuffer);
std::string path;
@@ -818,6 +851,7 @@ DWORD WIN_FUNC GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
}
DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCurrentDirectoryW(%u, %p)\n", nBufferLength, lpBuffer);
std::string path;
@@ -843,6 +877,7 @@ DWORD WIN_FUNC GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
}
int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetCurrentDirectoryA(%s)\n", lpPathName ? lpPathName : "(null)");
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -861,6 +896,7 @@ int WIN_FUNC SetCurrentDirectoryA(LPCSTR lpPathName) {
}
int WIN_FUNC SetCurrentDirectoryW(LPCWSTR lpPathName) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("SetCurrentDirectoryW\n");
if (!lpPathName) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -871,6 +907,7 @@ int WIN_FUNC SetCurrentDirectoryW(LPCWSTR lpPathName) {
}
DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLongPathNameA(%s, %p, %u)\n", lpszShortPath ? lpszShortPath : "(null)", lpszLongPath, cchBuffer);
if (!lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -901,6 +938,7 @@ DWORD WIN_FUNC GetLongPathNameA(LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD
}
DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLongPathNameW(%p, %p, %u)\n", lpszShortPath, lpszLongPath, cchBuffer);
if (!lpszShortPath) {
wibo::lastError = ERROR_INVALID_PARAMETER;
@@ -931,6 +969,7 @@ DWORD WIN_FUNC GetLongPathNameW(LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWOR
BOOL WIN_FUNC GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetDiskFreeSpaceA(%s)\n", lpRootPathName ? lpRootPathName : "(null)");
struct statvfs buf{};
std::string resolvedPath;
@@ -983,6 +1022,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerClust
BOOL WIN_FUNC GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters) {
WIN_API_SEGMENT_GUARD();
std::string rootPath = wideStringToString(lpRootPathName);
return GetDiskFreeSpaceA(lpRootPathName ? rootPath.c_str() : nullptr, lpSectorsPerCluster, lpBytesPerSector,
lpNumberOfFreeClusters, lpTotalNumberOfClusters);
@@ -990,6 +1030,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceW(LPCWSTR lpRootPathName, LPDWORD lpSectorsPerClus
BOOL WIN_FUNC GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, uint64_t *lpFreeBytesAvailableToCaller,
uint64_t *lpTotalNumberOfBytes, uint64_t *lpTotalNumberOfFreeBytes) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetDiskFreeSpaceExA(%s)\n", lpDirectoryName ? lpDirectoryName : "(null)");
struct statvfs buf{};
std::string resolvedPath;
@@ -1026,6 +1067,7 @@ BOOL WIN_FUNC GetDiskFreeSpaceExA(LPCSTR lpDirectoryName, uint64_t *lpFreeBytesA
BOOL WIN_FUNC GetDiskFreeSpaceExW(LPCWSTR lpDirectoryName, uint64_t *lpFreeBytesAvailableToCaller,
uint64_t *lpTotalNumberOfBytes, uint64_t *lpTotalNumberOfFreeBytes) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetDiskFreeSpaceExW -> ");
std::string directoryName = wideStringToString(lpDirectoryName);
return GetDiskFreeSpaceExA(lpDirectoryName ? directoryName.c_str() : nullptr, lpFreeBytesAvailableToCaller,

11
dll/kernel32/wincon.cpp
View File

@@ -9,6 +9,7 @@
namespace kernel32 {
BOOL WIN_FUNC GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetConsoleMode(%p)\n", hConsoleHandle);
if (lpMode) {
*lpMode = 0;
@@ -18,6 +19,7 @@ BOOL WIN_FUNC GetConsoleMode(HANDLE hConsoleHandle, LPDWORD lpMode) {
}
BOOL WIN_FUNC SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetConsoleMode(%p, 0x%x)\n", hConsoleHandle, dwMode);
(void)hConsoleHandle;
(void)dwMode;
@@ -26,18 +28,21 @@ BOOL WIN_FUNC SetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode) {
}
UINT WIN_FUNC GetConsoleCP() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetConsoleCP() -> 65001\n");
wibo::lastError = ERROR_SUCCESS;
return 65001; // UTF-8
}
UINT WIN_FUNC GetConsoleOutputCP() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetConsoleOutputCP() -> 65001\n");
wibo::lastError = ERROR_SUCCESS;
return 65001; // UTF-8
}
BOOL WIN_FUNC SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: SetConsoleCtrlHandler(%p, %u)\n", reinterpret_cast<const void *>(HandlerRoutine), Add);
(void)HandlerRoutine;
(void)Add;
@@ -46,6 +51,7 @@ BOOL WIN_FUNC SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine, BOOL Add) {
}
BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_BUFFER_INFO *lpConsoleScreenBufferInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetConsoleScreenBufferInfo(%p, %p)\n", hConsoleOutput, lpConsoleScreenBufferInfo);
(void)hConsoleOutput;
if (!lpConsoleScreenBufferInfo) {
@@ -63,6 +69,7 @@ BOOL WIN_FUNC GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, CONSOLE_SCREEN_B
BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite,
LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("WriteConsoleW(%p, %p, %u, %p, %p)\n", hConsoleOutput, lpBuffer, nNumberOfCharsToWrite,
lpNumberOfCharsWritten, lpReserved);
(void)lpReserved;
@@ -90,6 +97,7 @@ BOOL WIN_FUNC WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumb
}
DWORD WIN_FUNC GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetConsoleTitleA(%p, %u)\n", lpConsoleTitle, nSize);
if (lpConsoleTitle && nSize > 0) {
lpConsoleTitle[0] = '\0';
@@ -99,6 +107,7 @@ DWORD WIN_FUNC GetConsoleTitleA(LPSTR lpConsoleTitle, DWORD nSize) {
}
DWORD WIN_FUNC GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetConsoleTitleW(%p, %u)\n", lpConsoleTitle, nSize);
if (lpConsoleTitle && nSize > 0) {
lpConsoleTitle[0] = 0;
@@ -109,6 +118,7 @@ DWORD WIN_FUNC GetConsoleTitleW(LPWSTR lpConsoleTitle, DWORD nSize) {
BOOL WIN_FUNC PeekConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DWORD nLength,
LPDWORD lpNumberOfEventsRead) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: PeekConsoleInputA(%p, %p, %u)\n", hConsoleInput, lpBuffer, nLength);
(void)hConsoleInput;
(void)lpBuffer;
@@ -122,6 +132,7 @@ BOOL WIN_FUNC PeekConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DW
BOOL WIN_FUNC ReadConsoleInputA(HANDLE hConsoleInput, INPUT_RECORD *lpBuffer, DWORD nLength,
LPDWORD lpNumberOfEventsRead) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: ReadConsoleInputA(%p, %p, %u)\n", hConsoleInput, lpBuffer, nLength);
(void)hConsoleInput;
(void)lpBuffer;

16
dll/kernel32/winnls.cpp
View File

@@ -82,22 +82,26 @@ std::string localeInfoString(int LCType) {
namespace kernel32 {
UINT WIN_FUNC GetACP() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetACP() -> %u\n", 28591);
wibo::lastError = ERROR_SUCCESS;
return 28591; // Latin1 (ISO/IEC 8859-1)
}
LANGID WIN_FUNC GetSystemDefaultLangID() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetSystemDefaultLangID()\n");
return 0;
}
LANGID WIN_FUNC GetUserDefaultUILanguage() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: GetUserDefaultUILanguage()\n");
return 0;
}
BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetCPInfo(%u, %p)\n", CodePage, lpCPInfo);
(void)CodePage;
@@ -117,6 +121,7 @@ BOOL WIN_FUNC GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo) {
int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int cchCount1, LPCSTR lpString2,
int cchCount2) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CompareStringA(%u, %u, %s, %d, %s, %d)\n", Locale, dwCmpFlags, lpString1 ? lpString1 : "(null)",
cchCount1, lpString2 ? lpString2 : "(null)", cchCount2);
(void)Locale;
@@ -140,6 +145,7 @@ int WIN_FUNC CompareStringA(LCID Locale, DWORD dwCmpFlags, LPCSTR lpString1, int
int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int cchCount1, LPCWCH lpString2,
int cchCount2) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("CompareStringW(%u, %u, %p, %d, %p, %d)\n", Locale, dwCmpFlags, lpString1, cchCount1, lpString2,
cchCount2);
(void)Locale;
@@ -155,6 +161,7 @@ int WIN_FUNC CompareStringW(LCID Locale, DWORD dwCmpFlags, LPCWCH lpString1, int
}
BOOL WIN_FUNC IsValidCodePage(UINT CodePage) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsValidCodePage(%u)\n", CodePage);
(void)CodePage;
wibo::lastError = ERROR_SUCCESS;
@@ -162,6 +169,7 @@ BOOL WIN_FUNC IsValidCodePage(UINT CodePage) {
}
BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsValidLocale(%u, 0x%x)\n", Locale, dwFlags);
(void)Locale;
if (dwFlags != 0 && (dwFlags & ~(LCID_INSTALLED | LCID_SUPPORTED | LCID_ALTERNATE_SORTS)) != 0) {
@@ -173,6 +181,7 @@ BOOL WIN_FUNC IsValidLocale(LCID Locale, DWORD dwFlags) {
}
int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLocaleInfoA(%u, %u, %p, %d)\n", Locale, LCType, lpLCData, cchData);
(void)Locale;
@@ -198,6 +207,7 @@ int WIN_FUNC GetLocaleInfoA(LCID Locale, LCTYPE LCType, LPSTR lpLCData, int cchD
}
int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cchData) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetLocaleInfoW(%u, %u, %p, %d)\n", Locale, LCType, lpLCData, cchData);
(void)Locale;
@@ -224,6 +234,7 @@ int WIN_FUNC GetLocaleInfoW(LCID Locale, LCTYPE LCType, LPWSTR lpLCData, int cch
}
BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlags) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("EnumSystemLocalesA(%p, 0x%x)\n", lpLocaleEnumProc, dwFlags);
(void)dwFlags;
if (!lpLocaleEnumProc) {
@@ -237,12 +248,14 @@ BOOL WIN_FUNC EnumSystemLocalesA(LOCALE_ENUMPROCA lpLocaleEnumProc, DWORD dwFlag
}
LCID WIN_FUNC GetUserDefaultLCID() {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("GetUserDefaultLCID()\n");
wibo::lastError = ERROR_SUCCESS;
return 0x0409; // en-US
}
BOOL WIN_FUNC IsDBCSLeadByte(BYTE TestChar) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsDBCSLeadByte(%u)\n", TestChar);
(void)TestChar;
wibo::lastError = ERROR_SUCCESS;
@@ -250,6 +263,7 @@ BOOL WIN_FUNC IsDBCSLeadByte(BYTE TestChar) {
}
BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsDBCSLeadByteEx(%u, %u)\n", CodePage, TestChar);
auto inRanges = [TestChar](std::initializer_list<std::pair<uint8_t, uint8_t>> ranges) -> BOOL {
@@ -282,6 +296,7 @@ BOOL WIN_FUNC IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar) {
}
int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cchSrc, LPWSTR lpDestStr, int cchDest) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LCMapStringW(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest);
(void)Locale;
if (!lpSrcStr || cchSrc == 0) {
@@ -330,6 +345,7 @@ int WIN_FUNC LCMapStringW(LCID Locale, DWORD dwMapFlags, LPCWCH lpSrcStr, int cc
}
int WIN_FUNC LCMapStringA(LCID Locale, DWORD dwMapFlags, LPCCH lpSrcStr, int cchSrc, LPSTR lpDestStr, int cchDest) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("LCMapStringA(%u, 0x%x, %p, %d, %p, %d)\n", Locale, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest);
if (!lpSrcStr) {
wibo::lastError = ERROR_INVALID_PARAMETER;

1
dll/kernel32/winnt.cpp
View File

@@ -5,6 +5,7 @@
namespace kernel32 {
void WIN_FUNC RtlUnwind(PVOID TargetFrame, PVOID TargetIp, PEXCEPTION_RECORD ExceptionRecord, PVOID ReturnValue) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("RtlUnwind(%p, %p, %p, %p)\n", TargetFrame, TargetIp, ExceptionRecord, ReturnValue);
DEBUG_LOG("WARNING: Silently returning from RtlUnwind - exception handlers and clean up code may not be run\n");
}

3
dll/kernel32/wow64apiset.cpp
View File

@@ -7,6 +7,7 @@
namespace kernel32 {
BOOL WIN_FUNC Wow64DisableWow64FsRedirection(PVOID *OldValue) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: Wow64DisableWow64FsRedirection(%p)\n", OldValue);
if (OldValue) {
*OldValue = nullptr;
@@ -16,6 +17,7 @@ BOOL WIN_FUNC Wow64DisableWow64FsRedirection(PVOID *OldValue) {
}
BOOL WIN_FUNC Wow64RevertWow64FsRedirection(PVOID OldValue) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("STUB: Wow64RevertWow64FsRedirection(%p)\n", OldValue);
(void)OldValue;
wibo::lastError = ERROR_SUCCESS;
@@ -23,6 +25,7 @@ BOOL WIN_FUNC Wow64RevertWow64FsRedirection(PVOID OldValue) {
}
BOOL WIN_FUNC IsWow64Process(HANDLE hProcess, PBOOL Wow64Process) {
WIN_API_SEGMENT_GUARD();
DEBUG_LOG("IsWow64Process(%p, %p)\n", hProcess, Wow64Process);
if (!Wow64Process) {
wibo::lastError = ERROR_INVALID_PARAMETER;