vcc-fakes-kernel32.cpp@ 106842

Last change on this file since 106842 was 106842, checked in by vboxsync, 3 months ago
IPRT: We need RuntimeGuestR3Shared-x86 on arm64 for the guest addition installer helper, at least for the moment. Made it build w/o nocrt. jiraref:VBP-1253
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.9 KB

Line
1	/* $Id: vcc-fakes-kernel32.cpp 106842 2024-11-06 01:47:55Z vboxsync $ */
2	/** @file
3	* IPRT - Tricks to make the Visual C++ 2010 CRT work on NT4, W2K and XP.
4	*/
5
6	/*
7	* Copyright (C) 2012-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/cdefs.h>
42	#include <iprt/types.h>
43	#include <iprt/asm.h>
44	#include <iprt/assert.h>
45	#include <iprt/string.h>
46	#ifdef DEBUG
47	# include <stdio.h> /* _snprintf */
48	#endif
49
50	#ifndef RT_ARCH_X86
51	# error "This code is X86 only"
52	#endif
53
54	#include <iprt/nt/nt-and-windows.h>
55
56	#include "vcc-fakes.h"
57
58
59	/*********************************************************************************************************************************
60	* Defined Constants And Macros *
61	*********************************************************************************************************************************/
62	#ifndef HEAP_STANDARD
63	# define HEAP_STANDARD 0
64	#endif
65
66
67	/** Declare a kernel32 API.
68	* @note We are not exporting them as that causes duplicate symbol troubles in
69	* the OpenGL bits. */
70	#define DECL_KERNEL32(a_Type) extern "C" a_Type WINAPI
71
72	#if defined(WDK_NTDDI_VERSION) && defined(NTDDI_WIN10)
73	# if WDK_NTDDI_VERSION >= NTDDI_WIN10 /* In Windows 10 SDK the 'Sequence' field has been renamed to 'CpuId'. */
74	# define SLIST_HEADER_SEQUENCE_NOW_CALLED_CPUID
75	# endif
76	#endif
77
78
79
80	/*********************************************************************************************************************************
81	* Global Variables *
82	*********************************************************************************************************************************/
83	static volatile bool g_fInitialized = false;
84	#define MAKE_IMPORT_ENTRY(a_uMajorVer, a_uMinorVer, a_Name, a_cb) DECLARE_FUNCTION_POINTER(a_Name, a_cb)
85	#ifdef VCC_FAKES_TARGET_VCC100
86	# include "vcc-fakes-kernel32-100.h"
87	#elif defined(VCC_FAKES_TARGET_VCC140)
88	# include "vcc-fakes-kernel32-141.h"
89	#elif defined(VCC_FAKES_TARGET_VCC141)
90	# include "vcc-fakes-kernel32-141.h"
91	#elif defined(VCC_FAKES_TARGET_VCC142)
92	# include "vcc-fakes-kernel32-141.h"
93	#elif defined(VCC_FAKES_TARGET_VCC143)
94	# include "vcc-fakes-kernel32-141.h"
95	#else
96	# error "Port me!"
97	#endif
98
99
100	static BOOL FakeSetLastErrorFromNtStatus(NTSTATUS rcNt)
101	{
102	DWORD dwErr;
103	switch (rcNt)
104	{
105	case STATUS_INVALID_PARAMETER:
106	case STATUS_INVALID_PARAMETER_1:
107	case STATUS_INVALID_PARAMETER_2:
108	case STATUS_INVALID_PARAMETER_3:
109	case STATUS_INVALID_PARAMETER_4:
110	case STATUS_INVALID_PARAMETER_5:
111	case STATUS_INVALID_PARAMETER_6:
112	case STATUS_INVALID_PARAMETER_7:
113	case STATUS_INVALID_PARAMETER_8:
114	case STATUS_INVALID_PARAMETER_9:
115	case STATUS_INVALID_PARAMETER_10:
116	case STATUS_INVALID_PARAMETER_11:
117	case STATUS_INVALID_PARAMETER_12:
118	dwErr = ERROR_INVALID_PARAMETER;
119	break;
120
121	case STATUS_INVALID_HANDLE:
122	dwErr = ERROR_INVALID_HANDLE;
123	break;
124
125	case STATUS_ACCESS_DENIED:
126	dwErr = ERROR_ACCESS_DENIED;
127	break;
128
129	default:
130	dwErr = ERROR_INVALID_PARAMETER;
131	break;
132	}
133	SetLastError(dwErr);
134	return FALSE;
135	}
136
137
138
139	DECL_KERNEL32(PVOID) Fake_DecodePointer(PVOID pvEncoded)
140	{
141	return pvEncoded;
142	}
143
144
145	DECL_KERNEL32(PVOID) Fake_EncodePointer(PVOID pvNative)
146	{
147	return pvNative;
148	}
149
150
151	DECL_KERNEL32(BOOL) Fake_InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION pCritSect, DWORD cSpin)
152	{
153	RT_NOREF(cSpin);
154	InitializeCriticalSection(pCritSect);
155	return TRUE;
156	}
157
158
159	DECL_KERNEL32(HANDLE) Fake_CreateIoCompletionPort(HANDLE hFile, HANDLE hExistingCompletionPort, ULONG_PTR uCompletionKey,
160	DWORD cConcurrentThreads)
161	{
162	RT_NOREF(hFile, hExistingCompletionPort, uCompletionKey, cConcurrentThreads);
163	SetLastError(ERROR_NOT_SUPPORTED);
164	return NULL;
165	}
166
167
168	DECL_KERNEL32(BOOL) Fake_GetQueuedCompletionStatus(HANDLE hCompletionPort, PDWORD_PTR pcbTransfered, PULONG_PTR puCompletionKey,
169	LPOVERLAPPED *ppOverlapped, DWORD cMs)
170	{
171	RT_NOREF(hCompletionPort, pcbTransfered, puCompletionKey, ppOverlapped, cMs);
172	SetLastError(ERROR_NOT_SUPPORTED);
173	return FALSE;
174	}
175
176
177	DECL_KERNEL32(BOOL) Fake_PostQueuedCompletionStatus(HANDLE hCompletionPort, DWORD cbTransfered, ULONG_PTR uCompletionKey,
178	LPOVERLAPPED pOverlapped)
179	{
180	RT_NOREF(hCompletionPort, cbTransfered, uCompletionKey, pOverlapped);
181	SetLastError(ERROR_NOT_SUPPORTED);
182	return FALSE;
183	}
184
185
186	DECL_KERNEL32(BOOL) Fake_HeapSetInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass, PVOID pvBuf, SIZE_T cbBuf)
187	{
188	RT_NOREF(hHeap);
189	if (enmInfoClass == HeapCompatibilityInformation)
190	{
191	if ( cbBuf != sizeof(ULONG)
192	\|\| !pvBuf
193	\|\| *(PULONG)pvBuf == HEAP_STANDARD
194	)
195	{
196	SetLastError(ERROR_INVALID_PARAMETER);
197	return FALSE;
198	}
199	return TRUE;
200	}
201
202	SetLastError(ERROR_INVALID_PARAMETER);
203	return FALSE;
204	}
205
206
207	DECL_KERNEL32(BOOL) Fake_HeapQueryInformation(HANDLE hHeap, HEAP_INFORMATION_CLASS enmInfoClass,
208	PVOID pvBuf, SIZE_T cbBuf, PSIZE_T pcbRet)
209	{
210	RT_NOREF(hHeap);
211	if (enmInfoClass == HeapCompatibilityInformation)
212	{
213	*pcbRet = sizeof(ULONG);
214	if (cbBuf < sizeof(ULONG) \|\| !pvBuf)
215	{
216	SetLastError(ERROR_INSUFFICIENT_BUFFER);
217	return FALSE;
218	}
219	*(PULONG)pvBuf = HEAP_STANDARD;
220	return TRUE;
221	}
222
223	SetLastError(ERROR_INVALID_PARAMETER);
224	return FALSE;
225	}
226
227
228	/* These are used by INTEL\mt_obj\Timer.obj: */
229
230	DECL_KERNEL32(HANDLE) Fake_CreateTimerQueue(void)
231	{
232	SetLastError(ERROR_NOT_SUPPORTED);
233	return NULL;
234	}
235
236	DECL_KERNEL32(BOOL) Fake_CreateTimerQueueTimer(PHANDLE phTimer, HANDLE hTimerQueue, WAITORTIMERCALLBACK pfnCallback, PVOID pvUser,
237	DWORD msDueTime, DWORD msPeriod, ULONG fFlags)
238	{
239	NOREF(phTimer); NOREF(hTimerQueue); NOREF(pfnCallback); NOREF(pvUser); NOREF(msDueTime); NOREF(msPeriod); NOREF(fFlags);
240	SetLastError(ERROR_NOT_SUPPORTED);
241	return FALSE;
242	}
243
244	DECL_KERNEL32(BOOL) Fake_DeleteTimerQueueTimer(HANDLE hTimerQueue, HANDLE hTimer, HANDLE hEvtCompletion)
245	{
246	NOREF(hTimerQueue); NOREF(hTimer); NOREF(hEvtCompletion);
247	SetLastError(ERROR_NOT_SUPPORTED);
248	return FALSE;
249	}
250
251	/* This is used by several APIs. */
252
253	DECL_KERNEL32(VOID) Fake_InitializeSListHead(PSLIST_HEADER pHead)
254	{
255	pHead->Alignment = 0;
256	}
257
258
259	DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedFlushSList(PSLIST_HEADER pHead)
260	{
261	PSLIST_ENTRY pRet = NULL;
262	if (pHead->Next.Next)
263	{
264	for (;;)
265	{
266	SLIST_HEADER OldHead = *pHead;
267	SLIST_HEADER NewHead;
268	NewHead.Alignment = 0;
269	#ifdef SLIST_HEADER_SEQUENCE_NOW_CALLED_CPUID
270	NewHead.CpuId = OldHead.CpuId + 1;
271	#else
272	NewHead.Sequence = OldHead.Sequence + 1;
273	#endif
274	if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
275	{
276	pRet = OldHead.Next.Next;
277	break;
278	}
279	}
280	}
281	return pRet;
282	}
283
284	DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedPopEntrySList(PSLIST_HEADER pHead)
285	{
286	PSLIST_ENTRY pRet = NULL;
287	for (;;)
288	{
289	SLIST_HEADER OldHead = *pHead;
290	pRet = OldHead.Next.Next;
291	if (pRet)
292	{
293	SLIST_HEADER NewHead;
294	__try
295	{
296	NewHead.Next.Next = pRet->Next;
297	}
298	__except(EXCEPTION_EXECUTE_HANDLER)
299	{
300	continue;
301	}
302	NewHead.Depth = OldHead.Depth - 1;
303	#ifdef SLIST_HEADER_SEQUENCE_NOW_CALLED_CPUID
304	NewHead.CpuId = OldHead.CpuId + 1;
305	#else
306	NewHead.Sequence = OldHead.Sequence + 1;
307	#endif
308	if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
309	break;
310	}
311	else
312	break;
313	}
314	return pRet;
315	}
316
317	DECL_KERNEL32(PSLIST_ENTRY) Fake_InterlockedPushEntrySList(PSLIST_HEADER pHead, PSLIST_ENTRY pEntry)
318	{
319	PSLIST_ENTRY pRet = NULL;
320	for (;;)
321	{
322	SLIST_HEADER OldHead = *pHead;
323	pRet = OldHead.Next.Next;
324	pEntry->Next = pRet;
325	SLIST_HEADER NewHead;
326	NewHead.Next.Next = pEntry;
327	NewHead.Depth = OldHead.Depth + 1;
328	#ifdef SLIST_HEADER_SEQUENCE_NOW_CALLED_CPUID
329	NewHead.CpuId = OldHead.CpuId + 1;
330	#else
331	NewHead.Sequence = OldHead.Sequence + 1;
332	#endif
333	if (ASMAtomicCmpXchgU64(&pHead->Alignment, NewHead.Alignment, OldHead.Alignment))
334	break;
335	}
336	return pRet;
337	}
338
339	DECL_KERNEL32(WORD) Fake_QueryDepthSList(PSLIST_HEADER pHead)
340	{
341	return pHead->Depth;
342	}
343
344
345	/* curl drags these in: */
346	DECL_KERNEL32(BOOL) Fake_VerifyVersionInfoA(LPOSVERSIONINFOEXA pInfo, DWORD fTypeMask, DWORDLONG fConditionMask)
347	{
348	OSVERSIONINFOEXA VerInfo;
349	RT_ZERO(VerInfo);
350	VerInfo.dwOSVersionInfoSize = sizeof(VerInfo);
351	if (!GetVersionExA((OSVERSIONINFO *)&VerInfo))
352	{
353	RT_ZERO(VerInfo);
354	VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
355	BOOL fRet = GetVersionExA((OSVERSIONINFO *)&VerInfo);
356	if (fRet)
357	{ /* likely */ }
358	else
359	{
360	MY_ASSERT(false, "VerifyVersionInfoA: #1");
361	return FALSE;
362	}
363	}
364
365	BOOL fRet = TRUE;
366	for (unsigned i = 0; i < 8 && fRet; i++)
367	if (fTypeMask & RT_BIT_32(i))
368	{
369	uint32_t uLeft, uRight;
370	switch (RT_BIT_32(i))
371	{
372	#define MY_CASE(a_Num, a_Member) case a_Num: uLeft = VerInfo.a_Member; uRight = pInfo->a_Member; break
373	MY_CASE(VER_MINORVERSION, dwMinorVersion);
374	MY_CASE(VER_MAJORVERSION, dwMajorVersion);
375	MY_CASE(VER_BUILDNUMBER, dwBuildNumber);
376	MY_CASE(VER_PLATFORMID, dwPlatformId);
377	MY_CASE(VER_SERVICEPACKMINOR, wServicePackMinor);
378	MY_CASE(VER_SERVICEPACKMAJOR, wServicePackMinor);
379	MY_CASE(VER_SUITENAME, wSuiteMask);
380	MY_CASE(VER_PRODUCT_TYPE, wProductType);
381	#undef MY_CASE
382	default: uLeft = uRight = 0; MY_ASSERT(false, "VerifyVersionInfoA: #2");
383	}
384	switch ((uint8_t)(fConditionMask >> (i*8)))
385	{
386	case VER_EQUAL: fRet = uLeft == uRight; break;
387	case VER_GREATER: fRet = uLeft > uRight; break;
388	case VER_GREATER_EQUAL: fRet = uLeft >= uRight; break;
389	case VER_LESS: fRet = uLeft < uRight; break;
390	case VER_LESS_EQUAL: fRet = uLeft <= uRight; break;
391	case VER_AND: fRet = (uLeft & uRight) == uRight; break;
392	case VER_OR: fRet = (uLeft & uRight) != 0; break;
393	default: fRet = FALSE; MY_ASSERT(false, "VerifyVersionInfoA: #3"); break;
394	}
395	}
396
397	return fRet;
398	}
399
400
401	DECL_KERNEL32(ULONGLONG) Fake_VerSetConditionMask(ULONGLONG fConditionMask, DWORD fTypeMask, BYTE bOperator)
402	{
403	for (unsigned i = 0; i < 8; i++)
404	if (fTypeMask & RT_BIT_32(i))
405	{
406	uint64_t fMask = UINT64_C(0xff) << (i*8);
407	fConditionMask &= ~fMask;
408	fConditionMask \|= (uint64_t)bOperator << (i*8);
409
410	}
411	return fConditionMask;
412	}
413
414
415	#if VCC_FAKES_TARGET >= 140
416	/** @since 5.0 (windows 2000) */
417	DECL_KERNEL32(BOOL) Fake_GetModuleHandleExW(DWORD dwFlags, LPCWSTR pwszModuleName, HMODULE *phModule)
418	{
419	HMODULE hmod;
420	if (dwFlags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS)
421	{
422	/** @todo search the loader list. */
423	SetLastError(ERROR_NOT_SUPPORTED);
424	return FALSE;
425	}
426	else
427	{
428	hmod = GetModuleHandleW(pwszModuleName);
429	if (!hmod)
430	return FALSE;
431	}
432
433	/*
434	* Get references to the module.
435	*/
436	if ( !(dwFlags & (GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT \| GET_MODULE_HANDLE_EX_FLAG_PIN))
437	&& GetModuleHandleW(NULL) != hmod)
438	{
439	WCHAR wszModule[MAX_PATH];
440	if (GetModuleFileNameW(hmod, wszModule, RT_ELEMENTS(wszModule)) > 0)
441	{
442	if (dwFlags & GET_MODULE_HANDLE_EX_FLAG_PIN)
443	{
444	uint32_t cRefs = 32;
445	while (cRefs-- > 0)
446	LoadLibraryW(wszModule);
447	}
448	else if (!LoadLibraryW(wszModule))
449	return FALSE;
450	}
451	}
452
453	*phModule = hmod;
454	return TRUE;
455	}
456	#endif /* VCC_FAKES_TARGET >= 141 */
457
458
459	#if VCC_FAKES_TARGET >= 140
460	/** @since 5.0 (windows 2000) */
461	DECL_KERNEL32(BOOL) Fake_SetFilePointerEx(HANDLE hFile, LARGE_INTEGER offDistanceToMove,
462	PLARGE_INTEGER pNewFilePointer, DWORD dwMoveMethod)
463	{
464	NTSTATUS rcNt;
465	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
466
467	FILE_POSITION_INFORMATION PosInfo;
468	switch (dwMoveMethod)
469	{
470	case FILE_BEGIN:
471	PosInfo.CurrentByteOffset = offDistanceToMove;
472	break;
473
474	case FILE_CURRENT:
475	PosInfo.CurrentByteOffset.QuadPart = INT64_MAX;
476	rcNt = NtQueryInformationFile(hFile, &Ios, &PosInfo, sizeof(PosInfo), FilePositionInformation);
477	if (NT_SUCCESS(rcNt))
478	{
479	PosInfo.CurrentByteOffset.QuadPart += offDistanceToMove.QuadPart;
480	break;
481	}
482	return FakeSetLastErrorFromNtStatus(rcNt);
483
484	case FILE_END:
485	{
486	FILE_STANDARD_INFO StdInfo = { {{0}}, {{0}}, 0, 0, 0 };
487	rcNt = NtQueryInformationFile(hFile, &Ios, &StdInfo, sizeof(StdInfo), FileStandardInformation);
488	if (NT_SUCCESS(rcNt))
489	{
490	PosInfo.CurrentByteOffset.QuadPart = offDistanceToMove.QuadPart + StdInfo.EndOfFile.QuadPart;
491	break;
492	}
493	return FakeSetLastErrorFromNtStatus(rcNt);
494	}
495
496	default:
497	SetLastError(ERROR_INVALID_PARAMETER);
498	return FALSE;
499	}
500
501	rcNt = NtSetInformationFile(hFile, &Ios, &PosInfo, sizeof(PosInfo), FilePositionInformation);
502	if (NT_SUCCESS(rcNt))
503	{
504	if (pNewFilePointer)
505	*pNewFilePointer = PosInfo.CurrentByteOffset;
506	return TRUE;
507	}
508	return FakeSetLastErrorFromNtStatus(rcNt);
509	}
510	#endif /* VCC_FAKES_TARGET >= 140 */
511
512
513	#if VCC_FAKES_TARGET >= 140
514	/** @since 5.0 (windows 2000) */
515	DECL_KERNEL32(BOOL) Fake_GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER pcbFile)
516	{
517	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
518	FILE_STANDARD_INFO StdInfo = { {{0}}, {{0}}, 0, 0, 0 };
519	NTSTATUS rcNt = NtQueryInformationFile(hFile, &Ios, &StdInfo, sizeof(StdInfo), FileStandardInformation);
520	if (NT_SUCCESS(rcNt))
521	{
522	*pcbFile = StdInfo.EndOfFile;
523	return TRUE;
524	}
525	return FakeSetLastErrorFromNtStatus(rcNt);
526	}
527	#endif /* VCC_FAKES_TARGET >= 140 */
528
529
530
531
532	/*
533	* NT 3.51 stuff.
534	*/
535
536	#if VCC_FAKES_TARGET >= 140
537	/** @since 4.0 */
538	DECL_KERNEL32(HANDLE) Fake_FindFirstFileExW(LPCWSTR pwszFileName, FINDEX_INFO_LEVELS enmInfoLevel, LPVOID pvFindFileData,
539	FINDEX_SEARCH_OPS enmSearchOp, LPVOID pvSearchFilter, DWORD dwAdditionalFlags)
540	{
541	// STL: FindFirstFileExW(, FindExInfoBasic, , FindExSearchNameMatch, NULL, 0);
542	// CRT/_findfile: FindFirstFileExW(, FindExInfoStandard, , FindExSearchNameMatch, NULL, 0);
543	// CRT/argv_wildcards: FindFirstFileExW(, FindExInfoStandard, , FindExSearchNameMatch, NULL, 0);
544	MY_ASSERT_STMT_RETURN(dwAdditionalFlags == 0, SetLastError(ERROR_INVALID_PARAMETER), INVALID_HANDLE_VALUE);
545	MY_ASSERT_STMT_RETURN(pvSearchFilter == NULL, SetLastError(ERROR_INVALID_PARAMETER), INVALID_HANDLE_VALUE);
546	MY_ASSERT_STMT_RETURN(enmSearchOp == FindExSearchNameMatch, SetLastError(ERROR_INVALID_PARAMETER), INVALID_HANDLE_VALUE);
547	MY_ASSERT_STMT_RETURN(enmInfoLevel == FindExInfoStandard \|\| enmInfoLevel == FindExInfoBasic,
548	SetLastError(ERROR_INVALID_PARAMETER), INVALID_HANDLE_VALUE);
549
550	return FindFirstFileW(pwszFileName, (WIN32_FIND_DATAW *)pvFindFileData);
551	}
552	#endif /* VCC_FAKES_TARGET >= 140 */
553
554
555	DECL_KERNEL32(BOOL) Fake_IsProcessorFeaturePresent(DWORD enmProcessorFeature)
556	{
557	/* Could make more of an effort here... */
558	RT_NOREF(enmProcessorFeature);
559	return FALSE;
560	}
561
562
563	DECL_KERNEL32(BOOL) Fake_CancelIo(HANDLE hHandle)
564	{
565	/* All NT versions the NTDLL API this corresponds to. */
566	RESOLVE_NTDLL_API(NtCancelIoFile);
567	if (pfnNtCancelIoFile)
568	{
569	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
570	NTSTATUS rcNt = pfnNtCancelIoFile(hHandle, &Ios);
571	if (RT_SUCCESS(rcNt))
572	return TRUE;
573	if (rcNt == STATUS_INVALID_HANDLE)
574	SetLastError(ERROR_INVALID_HANDLE);
575	else
576	SetLastError(ERROR_INVALID_FUNCTION);
577	}
578	else
579	SetLastError(ERROR_NOT_SUPPORTED);
580	return FALSE;
581	}
582
583
584	/*
585	* NT 3.50 stuff.
586	*/
587
588	#if VCC_FAKES_TARGET >= 140
589	/** @since 3.51 */
590	DECL_KERNEL32(VOID) Fake_FreeLibraryAndExitThread(HMODULE hLibModule, DWORD dwExitCode)
591	{
592	if (hLibModule)
593	FreeModule(hLibModule);
594	ExitThread(dwExitCode);
595	}
596	#endif /* VCC_FAKES_TARGET >= 140 */
597
598
599	DECL_KERNEL32(BOOL) Fake_IsDebuggerPresent(VOID)
600	{
601	/* Fallback: */
602	return FALSE;
603	}
604
605
606	DECL_KERNEL32(VOID) Fake_GetSystemTimeAsFileTime(LPFILETIME pTime)
607	{
608	DWORD dwVersion = GetVersion();
609	if ( (dwVersion & 0xff) > 3
610	\|\| ( (dwVersion & 0xff) == 3
611	&& ((dwVersion >> 8) & 0xff) >= 50) )
612	{
613	PKUSER_SHARED_DATA pUsd = (PKUSER_SHARED_DATA)MM_SHARED_USER_DATA_VA;
614
615	/* use interrupt time */
616	LARGE_INTEGER Time;
617	do
618	{
619	Time.HighPart = pUsd->SystemTime.High1Time;
620	Time.LowPart = pUsd->SystemTime.LowPart;
621	} while (pUsd->SystemTime.High2Time != Time.HighPart);
622
623	pTime->dwHighDateTime = Time.HighPart;
624	pTime->dwLowDateTime = Time.LowPart;
625	}
626	else
627	{
628	/* NT 3.1 didn't have a KUSER_SHARED_DATA nor a GetSystemTimeAsFileTime export. */
629	SYSTEMTIME SystemTime;
630	GetSystemTime(&SystemTime);
631	BOOL fRet = SystemTimeToFileTime(&SystemTime, pTime);
632	if (fRet)
633	{ /* likely */ }
634	else
635	{
636	MY_ASSERT(false, "GetSystemTimeAsFileTime: #2");
637	pTime->dwHighDateTime = 0;
638	pTime->dwLowDateTime = 0;
639	}
640	}
641	}
642
643
644	/*
645	* NT 3.1 stuff.
646	*/
647
648	DECL_KERNEL32(BOOL) Fake_GetVersionExA(LPOSVERSIONINFOA pInfo)
649	{
650	DWORD dwVersion = GetVersion();
651
652	/* Common fields: */
653	pInfo->dwMajorVersion = dwVersion & 0xff;
654	pInfo->dwMinorVersion = (dwVersion >> 8) & 0xff;
655	if (!(dwVersion & RT_BIT_32(31)))
656	pInfo->dwBuildNumber = dwVersion >> 16;
657	else
658	pInfo->dwBuildNumber = 511;
659	pInfo->dwPlatformId = VER_PLATFORM_WIN32_NT;
660	/** @todo get CSD from registry. */
661	pInfo->szCSDVersion[0] = '\0';
662
663	/* OSVERSIONINFOEX fields: */
664	if (pInfo->dwOSVersionInfoSize > sizeof((*pInfo)))
665	{
666	LPOSVERSIONINFOEXA pInfoEx = (LPOSVERSIONINFOEXA)pInfo;
667	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wServicePackMinor))
668	{
669	pInfoEx->wServicePackMajor = 0;
670	pInfoEx->wServicePackMinor = 0;
671	}
672	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wSuiteMask))
673	pInfoEx->wSuiteMask = 0;
674	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXA, wProductType))
675	pInfoEx->wProductType = VER_NT_WORKSTATION;
676	if (pInfoEx->wReserved > RT_UOFFSETOF(OSVERSIONINFOEXA, wProductType))
677	pInfoEx->wReserved = 0;
678	}
679
680	return TRUE;
681	}
682
683
684	DECL_KERNEL32(BOOL) Fake_GetVersionExW(LPOSVERSIONINFOW pInfo)
685	{
686	DWORD dwVersion = GetVersion();
687
688	/* Common fields: */
689	pInfo->dwMajorVersion = dwVersion & 0xff;
690	pInfo->dwMinorVersion = (dwVersion >> 8) & 0xff;
691	if (!(dwVersion & RT_BIT_32(31)))
692	pInfo->dwBuildNumber = dwVersion >> 16;
693	else
694	pInfo->dwBuildNumber = 511;
695	pInfo->dwPlatformId = VER_PLATFORM_WIN32_NT;
696	/** @todo get CSD from registry. */
697	pInfo->szCSDVersion[0] = '\0';
698
699	/* OSVERSIONINFOEX fields: */
700	if (pInfo->dwOSVersionInfoSize > sizeof((*pInfo)))
701	{
702	LPOSVERSIONINFOEXW pInfoEx = (LPOSVERSIONINFOEXW)pInfo;
703	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wServicePackMinor))
704	{
705	pInfoEx->wServicePackMajor = 0;
706	pInfoEx->wServicePackMinor = 0;
707	}
708	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wSuiteMask))
709	pInfoEx->wSuiteMask = 0;
710	if (pInfoEx->dwOSVersionInfoSize > RT_UOFFSETOF(OSVERSIONINFOEXW, wProductType))
711	pInfoEx->wProductType = VER_NT_WORKSTATION;
712	if (pInfoEx->wReserved > RT_UOFFSETOF(OSVERSIONINFOEXW, wProductType))
713	pInfoEx->wReserved = 0;
714	}
715
716	return TRUE;
717	}
718
719
720	DECL_KERNEL32(LPWCH) Fake_GetEnvironmentStringsW(void)
721	{
722	/*
723	* Environment is ANSI in NT 3.1. We should only be here for NT 3.1.
724	* For now, don't try do a perfect job converting it, just do it.
725	*/
726	char pszzEnv = (char )RTNtCurrentPeb()->ProcessParameters->Environment;
727	size_t offEnv = 0;
728	while (pszzEnv[offEnv] != '\0')
729	{
730	size_t cchLen = strlen(&pszzEnv[offEnv]);
731	offEnv += cchLen + 1;
732	}
733	size_t const cchEnv = offEnv + 1;
734
735	PRTUTF16 pwszzEnv = (PRTUTF16)HeapAlloc(GetProcessHeap(), 0, cchEnv * sizeof(RTUTF16));
736	if (!pwszzEnv)
737	return NULL;
738	for (offEnv = 0; offEnv < cchEnv; offEnv++)
739	{
740	unsigned char ch = pwszzEnv[offEnv];
741	if (!(ch & 0x80))
742	pwszzEnv[offEnv] = ch;
743	else
744	pwszzEnv[offEnv] = '_';
745	}
746	return pwszzEnv;
747	}
748
749
750	DECL_KERNEL32(BOOL) Fake_FreeEnvironmentStringsW(LPWCH pwszzEnv)
751	{
752	if (pwszzEnv)
753	HeapFree(GetProcessHeap(), 0, pwszzEnv);
754	return TRUE;
755	}
756
757
758	DECL_KERNEL32(int) Fake_GetLocaleInfoA(LCID idLocale, LCTYPE enmType, LPSTR pData, int cchData)
759	{
760	NOREF(idLocale); NOREF(enmType); NOREF(pData); NOREF(cchData);
761	//MY_ASSERT(false, "GetLocaleInfoA: idLocale=%#x enmType=%#x cchData=%#x", idLocale, enmType, cchData);
762	MY_ASSERT(false, "GetLocaleInfoA");
763	SetLastError(ERROR_NOT_SUPPORTED);
764	return 0;
765	}
766
767
768	#if VCC_FAKES_TARGET >= 140
769	/** @since 3.51 */
770	DECL_KERNEL32(BOOL) Fake_EnumSystemLocalesW(LOCALE_ENUMPROCW pfnLocaleEnum, DWORD dwFlags)
771	{
772	RT_NOREF(pfnLocaleEnum, dwFlags);
773	SetLastError(ERROR_NOT_SUPPORTED);
774	return FALSE;
775	}
776	#endif /* VCC_FAKES_TARGET >= 140 */
777
778
779	DECL_KERNEL32(BOOL) Fake_EnumSystemLocalesA(LOCALE_ENUMPROCA pfnCallback, DWORD fFlags)
780	{
781	NOREF(pfnCallback); NOREF(fFlags);
782	//MY_ASSERT(false, "EnumSystemLocalesA: pfnCallback=%p fFlags=%#x", pfnCallback, fFlags);
783	MY_ASSERT(false, "EnumSystemLocalesA");
784	SetLastError(ERROR_NOT_SUPPORTED);
785	return FALSE;
786	}
787
788
789	DECL_KERNEL32(BOOL) Fake_IsValidLocale(LCID idLocale, DWORD fFlags)
790	{
791	NOREF(idLocale); NOREF(fFlags);
792	//MY_ASSERT(false, "IsValidLocale: idLocale fFlags=%#x", idLocale, fFlags);
793	MY_ASSERT(false, "IsValidLocale");
794	SetLastError(ERROR_NOT_SUPPORTED);
795	return FALSE;
796	}
797
798
799	DECL_KERNEL32(DWORD_PTR) Fake_SetThreadAffinityMask(HANDLE hThread, DWORD_PTR fAffinityMask)
800	{
801	SYSTEM_INFO SysInfo;
802	GetSystemInfo(&SysInfo);
803	//MY_ASSERT(false, "SetThreadAffinityMask: hThread=%p fAffinityMask=%p SysInfo.dwActiveProcessorMask=%p",
804	// hThread, fAffinityMask, SysInfo.dwActiveProcessorMask);
805	MY_ASSERT(false, "SetThreadAffinityMask");
806	if ( SysInfo.dwActiveProcessorMask == fAffinityMask
807	\|\| fAffinityMask == ~(DWORD_PTR)0)
808	return fAffinityMask;
809
810	SetLastError(ERROR_NOT_SUPPORTED);
811	RT_NOREF(hThread);
812	return 0;
813	}
814
815
816	DECL_KERNEL32(BOOL) Fake_GetProcessAffinityMask(HANDLE hProcess, PDWORD_PTR pfProcessAffinityMask, PDWORD_PTR pfSystemAffinityMask)
817	{
818	SYSTEM_INFO SysInfo;
819	GetSystemInfo(&SysInfo);
820	//MY_ASSERT(false, "GetProcessAffinityMask: SysInfo.dwActiveProcessorMask=%p", SysInfo.dwActiveProcessorMask);
821	MY_ASSERT(false, "GetProcessAffinityMask");
822	if (pfProcessAffinityMask)
823	*pfProcessAffinityMask = SysInfo.dwActiveProcessorMask;
824	if (pfSystemAffinityMask)
825	*pfSystemAffinityMask = SysInfo.dwActiveProcessorMask;
826	RT_NOREF(hProcess);
827	return TRUE;
828	}
829
830
831	DECL_KERNEL32(BOOL) Fake_GetHandleInformation(HANDLE hObject, DWORD *pfFlags)
832	{
833	OBJECT_HANDLE_FLAG_INFORMATION Info = { 0, 0 };
834	DWORD cbRet = sizeof(Info);
835	NTSTATUS rcNt = NtQueryObject(hObject, ObjectHandleFlagInformation, &Info, sizeof(Info), &cbRet);
836	if (NT_SUCCESS(rcNt))
837	{
838	*pfFlags = (Info.Inherit ? HANDLE_FLAG_INHERIT : 0)
839	\| (Info.ProtectFromClose ? HANDLE_FLAG_PROTECT_FROM_CLOSE : 0);
840	return TRUE;
841	}
842	*pfFlags = 0;
843	//MY_ASSERT(rcNt == STATUS_INVALID_HANDLE, "rcNt=%#x", rcNt);
844	MY_ASSERT(rcNt == STATUS_INVALID_HANDLE \|\| rcNt == STATUS_INVALID_INFO_CLASS, "GetHandleInformation");
845	SetLastError(rcNt == STATUS_INVALID_HANDLE ? ERROR_INVALID_HANDLE : ERROR_INVALID_FUNCTION); /* see also process-win.cpp */
846	return FALSE;
847	}
848
849
850	DECL_KERNEL32(BOOL) Fake_SetHandleInformation(HANDLE hObject, DWORD fMask, DWORD fFlags)
851	{
852	NOREF(hObject); NOREF(fMask); NOREF(fFlags);
853	SetLastError(ERROR_INVALID_FUNCTION);
854	return FALSE;
855	}
856
857
858
859	/**
860	* Resolves all the APIs ones and for all, updating the fake IAT entries.
861	*/
862	DECLASM(void) FakeResolve_kernel32(void)
863	{
864	CURRENT_VERSION_VARIABLE();
865
866	HMODULE hmod = GetModuleHandleW(L"kernel32");
867	MY_ASSERT(hmod != NULL, "kernel32");
868
869	#undef MAKE_IMPORT_ENTRY
870	#define MAKE_IMPORT_ENTRY(a_uMajorVer, a_uMinorVer, a_Name, a_cb) RESOLVE_IMPORT(a_uMajorVer, a_uMinorVer, a_Name, a_cb)
871	#ifdef VCC_FAKES_TARGET_VCC100
872	# include "vcc-fakes-kernel32-100.h"
873	#elif defined(VCC_FAKES_TARGET_VCC140)
874	# include "vcc-fakes-kernel32-141.h"
875	#elif defined(VCC_FAKES_TARGET_VCC141)
876	# include "vcc-fakes-kernel32-141.h"
877	#elif defined(VCC_FAKES_TARGET_VCC142)
878	# include "vcc-fakes-kernel32-141.h"
879	#elif defined(VCC_FAKES_TARGET_VCC143)
880	# include "vcc-fakes-kernel32-141.h"
881	#else
882	# error "Port me!"
883	#endif
884
885	g_fInitialized = true;
886	}
887
888
889	/* Dummy to force dragging in this object in the link, so the linker
890	won't accidentally use the symbols from kernel32. */
891	extern "C" int vcc100_kernel32_fakes_cpp(void)
892	{
893	return 42;
894	}
895

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/win/vcc-fakes-kernel32.cpp@ 106842

Download in other formats: