kWorker.c@ 3192

Last change on this file since 3192 was 3192, checked in by bird, 7 years ago
kmkbuiltin: funnel output thru output.c (usually via err.c).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 425.6 KB

Line
1	/* $Id: kWorker.c 3192 2018-03-26 20:25:56Z bird $ */
2	/** @file
3	* kWorker - experimental process reuse worker for Windows.
4	*
5	* Note! This module must be linked statically in order to avoid
6	* accidentally intercepting our own CRT calls.
7	*/
8
9	/*
10	* Copyright (c) 2016 knut st. osmundsen <[email protected]>
11	*
12	* This file is part of kBuild.
13	*
14	* kBuild is free software; you can redistribute it and/or modify
15	* it under the terms of the GNU General Public License as published by
16	* the Free Software Foundation; either version 3 of the License, or
17	* (at your option) any later version.
18	*
19	* kBuild is distributed in the hope that it will be useful,
20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22	* GNU General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
26	*
27	*/
28
29
30	/*********************************************************************************************************************************
31	* Header Files *
32	*********************************************************************************************************************************/
33	//#undef NDEBUG
34	//#define K_STRICT 1
35	//#define KW_LOG_ENABLED
36
37	#define PSAPI_VERSION 1
38	#include <k/kHlp.h>
39	#include <k/kLdr.h>
40
41	#include <stdio.h>
42	#include <intrin.h>
43	#include <setjmp.h>
44	#include <ctype.h>
45	#include <errno.h>
46	#include <process.h>
47
48	#include "nt/ntstat.h"
49	#include "kbuild_version.h"
50
51	#include "nt/ntstuff.h"
52	#include <psapi.h>
53
54	#include "nt/kFsCache.h"
55	#include "nt_fullpath.h"
56	#include "quote_argv.h"
57	#include "md5.h"
58	#include "console.h"
59
60	#include "../kmk/kmkbuiltin.h"
61
62
63	/*********************************************************************************************************************************
64	* Defined Constants And Macros *
65	*********************************************************************************************************************************/
66	/** @def WITH_TEMP_MEMORY_FILES
67	* Enables temporary memory files for cl.exe. */
68	#define WITH_TEMP_MEMORY_FILES
69
70	/** @def WITH_HASH_MD5_CACHE
71	* Enables caching of MD5 sums for cl.exe.
72	* This prevents wasting time on rehashing common headers each time
73	* they are included. */
74	#define WITH_HASH_MD5_CACHE
75
76	/** @def WITH_CRYPT_CTX_REUSE
77	* Enables reusing crypt contexts. The Visual C++ compiler always creates a
78	* context which is only used for MD5 and maybe some random bytes (VS 2010).
79	* So, only create it once and add a reference to it instead of creating new
80	* ones. Saves registry access among other things. */
81	#define WITH_CRYPT_CTX_REUSE
82
83	/** @def WITH_CONSOLE_OUTPUT_BUFFERING
84	* Enables buffering of all console output as well as removal of annoying
85	* source file echo by cl.exe. */
86	#define WITH_CONSOLE_OUTPUT_BUFFERING
87
88	/** @def WITH_STD_OUT_ERR_BUFFERING
89	* Enables buffering of standard output and standard error buffer as well as
90	* removal of annoying source file echo by cl.exe. */
91	#define WITH_STD_OUT_ERR_BUFFERING
92
93	/** @def WITH_LOG_FILE
94	* Log to file instead of stderr. */
95	#define WITH_LOG_FILE
96
97	/** @def WITH_HISTORY
98	* Keep history of the last jobs. For debugging. */
99	#define WITH_HISTORY
100
101	/** @def WITH_FIXED_VIRTUAL_ALLOCS
102	* Whether to pre allocate memory for known fixed VirtualAlloc calls (currently
103	* there is only one, but an important one, from cl.exe).
104	*/
105	#if K_ARCH == K_ARCH_X86_32
106	# define WITH_FIXED_VIRTUAL_ALLOCS
107	#endif
108
109	/** @def WITH_PCH_CACHING
110	* Enables read caching of precompiled header files. */
111	#if K_ARCH_BITS >= 64
112	# define WITH_PCH_CACHING
113	#endif
114
115
116	#ifndef NDEBUG
117	# define KW_LOG_ENABLED
118	#endif
119
120	/** @def KW_LOG
121	* Generic logging.
122	* @param a Argument list for kwDbgPrintf */
123	#ifdef KW_LOG_ENABLED
124	# define KW_LOG(a) kwDbgPrintf a
125	#else
126	# define KW_LOG(a) do { } while (0)
127	#endif
128
129	/** @def KWLDR_LOG
130	* Loader related logging.
131	* @param a Argument list for kwDbgPrintf */
132	#ifdef KW_LOG_ENABLED
133	# define KWLDR_LOG(a) kwDbgPrintf a
134	#else
135	# define KWLDR_LOG(a) do { } while (0)
136	#endif
137
138
139	/** @def KWFS_LOG
140	* FS cache logging.
141	* @param a Argument list for kwDbgPrintf */
142	#ifdef KW_LOG_ENABLED
143	# define KWFS_LOG(a) kwDbgPrintf a
144	#else
145	# define KWFS_LOG(a) do { } while (0)
146	#endif
147
148	/** @def KWOUT_LOG
149	* Output related logging.
150	* @param a Argument list for kwDbgPrintf */
151	#ifdef KW_LOG_ENABLED
152	# define KWOUT_LOG(a) kwDbgPrintf a
153	#else
154	# define KWOUT_LOG(a) do { } while (0)
155	#endif
156
157	/** @def KWCRYPT_LOG
158	* FS cache logging.
159	* @param a Argument list for kwDbgPrintf */
160	#ifdef KW_LOG_ENABLED
161	# define KWCRYPT_LOG(a) kwDbgPrintf a
162	#else
163	# define KWCRYPT_LOG(a) do { } while (0)
164	#endif
165
166	/** Converts a windows handle to a handle table index.
167	* @note We currently just mask off the 31th bit, and do no shifting or anything
168	* else to create an index of the handle.
169	* @todo consider shifting by 2 or 3. */
170	#define KW_HANDLE_TO_INDEX(a_hHandle) ((KUPTR)(a_hHandle) & ~(KUPTR)KU32_C(0x8000000))
171	/** Maximum handle value we can deal with. */
172	#define KW_HANDLE_MAX 0x20000
173
174	/** Max temporary file size (memory backed). */
175	#if K_ARCH_BITS >= 64
176	# define KWFS_TEMP_FILE_MAX (25610241024)
177	#else
178	# define KWFS_TEMP_FILE_MAX (6410241024)
179	#endif
180
181	/** Marks unfinished code. */
182	#if 1
183	# define KWFS_TODO() do { kwErrPrintf("\nHit TODO on line %u in %s!\n", __LINE__, __FUNCTION__); fflush(stderr); __debugbreak(); } while (0)
184	#else
185	# define KWFS_TODO() do { kwErrPrintf("\nHit TODO on line %u in %s!\n", __LINE__, __FUNCTION__); fflush(stderr); } while (0)
186	#endif
187
188	/** User data key for tools. */
189	#define KW_DATA_KEY_TOOL (~(KUPTR)16381)
190	/** User data key for a cached file. */
191	#define KW_DATA_KEY_CACHED_FILE (~(KUPTR)65521)
192
193	/** String constant comma length. */
194	#define TUPLE(a_sz) a_sz, sizeof(a_sz) - 1
195
196
197	/*********************************************************************************************************************************
198	* Structures and Typedefs *
199	*********************************************************************************************************************************/
200	typedef enum KWLOCATION
201	{
202	KWLOCATION_INVALID = 0,
203	KWLOCATION_EXE_DIR,
204	KWLOCATION_IMPORTER_DIR,
205	KWLOCATION_SYSTEM32,
206	KWLOCATION_UNKNOWN_NATIVE,
207	KWLOCATION_UNKNOWN,
208	} KWLOCATION;
209
210	typedef enum KWMODSTATE
211	{
212	KWMODSTATE_INVALID = 0,
213	KWMODSTATE_NEEDS_BITS,
214	KWMODSTATE_NEEDS_INIT,
215	KWMODSTATE_BEING_INITED,
216	KWMODSTATE_INIT_FAILED,
217	KWMODSTATE_READY,
218	} KWMODSTATE;
219
220	typedef struct KWMODULE *PKWMODULE;
221	typedef struct KWMODULE
222	{
223	/** Pointer to the next image. */
224	PKWMODULE pNext;
225	/** The normalized path to the image. */
226	const char *pszPath;
227	/** The hash of the program path. */
228	KU32 uHashPath;
229	/** Number of references. */
230	KU32 cRefs;
231	/** UTF-16 version of pszPath. */
232	const wchar_t *pwszPath;
233	/** The offset of the filename in pszPath. */
234	KU16 offFilename;
235	/** Set if executable. */
236	KBOOL fExe;
237	/** Set if native module entry. */
238	KBOOL fNative;
239	/** Loader module handle. */
240	PKLDRMOD pLdrMod;
241	/** The windows module handle. */
242	HMODULE hOurMod;
243	/** The of the loaded image bits. */
244	KSIZE cbImage;
245
246	union
247	{
248	/** Data for a manually loaded image. */
249	struct
250	{
251	/** Where we load the image. */
252	KU8 *pbLoad;
253	/** Virgin copy of the image. */
254	KU8 *pbCopy;
255	/** Ldr pvBits argument. This is NULL till we've successfully resolved
256	* the imports. */
257	void *pvBits;
258	/** The state. */
259	KWMODSTATE enmState;
260	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
261	/** The number of entries in the table. */
262	KU32 cFunctions;
263	/** The function table address (in the copy). */
264	PRUNTIME_FUNCTION paFunctions;
265	/** Set if we've already registered a function table already. */
266	KBOOL fRegisteredFunctionTable;
267	#endif
268	/** Set if we share memory with other executables. */
269	KBOOL fUseLdBuf;
270	/** Set after the first whole image copy is done. */
271	KBOOL fCanDoQuick;
272	/** Number of quick copy chunks. */
273	KU8 cQuickCopyChunks;
274	/** Number of quick zero chunks. */
275	KU8 cQuickZeroChunks;
276	/** Quicker image copy instructions that skips non-writable parts when
277	* possible. Need to check fCanDoQuick, fUseLdBuf and previous executable
278	* image. */
279	struct
280	{
281	/** The copy destination. */
282	KU8 *pbDst;
283	/** The copy source. */
284	KU8 const *pbSrc;
285	/** How much to copy. */
286	KSIZE cbToCopy;
287	} aQuickCopyChunks[3];
288	/** For handling BSS and zero alignment padding when using aQuickCopyChunks. */
289	struct
290	{
291	/** Where to start zeroing. */
292	KU8 *pbDst;
293	/** How much to zero. */
294	KSIZE cbToZero;
295	} aQuickZeroChunks[3];
296
297	/** TLS index if one was allocated, otherwise KU32_MAX. */
298	KU32 idxTls;
299	/** Offset (RVA) of the TLS initialization data. */
300	KU32 offTlsInitData;
301	/** Number of bytes of TLS initialization data. */
302	KU32 cbTlsInitData;
303	/** Number of allocated bytes for TLS. */
304	KU32 cbTlsAlloc;
305	/** Number of TLS callbacks. */
306	KU32 cTlsCallbacks;
307	/** Offset (RVA) of the TLS callback table. */
308	KU32 offTlsCallbacks;
309
310	/** Number of imported modules. */
311	KSIZE cImpMods;
312	/** Import array (variable size). */
313	PKWMODULE apImpMods[1];
314	} Manual;
315	} u;
316	} KWMODULE;
317
318
319	typedef struct KWDYNLOAD *PKWDYNLOAD;
320	typedef struct KWDYNLOAD
321	{
322	/** Pointer to the next in the list. */
323	PKWDYNLOAD pNext;
324
325	/** The module handle we present to the application.
326	* This is the LoadLibraryEx return value for special modules and the
327	* KWMODULE.hOurMod value for the others. */
328	HMODULE hmod;
329
330	/** The module for non-special resource stuff, NULL if special. */
331	PKWMODULE pMod;
332
333	/** The length of the LoadLibary filename. */
334	KSIZE cchRequest;
335	/** The LoadLibrary filename. */
336	char szRequest[1];
337	} KWDYNLOAD;
338
339
340	/**
341	* GetModuleHandle cache for system modules frequently queried.
342	*/
343	typedef struct KWGETMODULEHANDLECACHE
344	{
345	const char *pszName;
346	KU8 cchName;
347	KU8 cwcName;
348	const wchar_t *pwszName;
349	HANDLE hmod;
350	} KWGETMODULEHANDLECACHE;
351	typedef KWGETMODULEHANDLECACHE *PKWGETMODULEHANDLECACHE;
352
353
354	/**
355	* A cached file.
356	*/
357	typedef struct KFSWCACHEDFILE
358	{
359	/** The user data core. */
360	KFSUSERDATA Core;
361
362	/** Cached file handle. */
363	HANDLE hCached;
364	/** Cached file section handle. */
365	HANDLE hSection;
366	/** Cached file content. */
367	KU8 *pbCached;
368	/** The file size. */
369	KU32 cbCached;
370	#ifdef WITH_HASH_MD5_CACHE
371	/** Set if we've got a valid MD5 hash in abMd5Digest. */
372	KBOOL fValidMd5;
373	/** The MD5 digest if fValidMd5 is set. */
374	KU8 abMd5Digest[16];
375	#endif
376
377	/** Circular self reference. Prevents the object from ever going away and
378	* keeps it handy for debugging. */
379	PKFSOBJ pFsObj;
380	/** The file path (for debugging). */
381	char szPath[1];
382	} KFSWCACHEDFILE;
383	/** Pointer to a cached filed. */
384	typedef KFSWCACHEDFILE *PKFSWCACHEDFILE;
385
386	#ifdef WITH_HASH_MD5_CACHE
387
388	/** Pointer to a MD5 hash instance. */
389	typedef struct KWHASHMD5 *PKWHASHMD5;
390	/**
391	* A MD5 hash instance.
392	*/
393	typedef struct KWHASHMD5
394	{
395	/** The magic value. */
396	KUPTR uMagic;
397	/** Pointer to the next hash handle. */
398	PKWHASHMD5 pNext;
399	/** The cached file we've associated this handle with. */
400	PKFSWCACHEDFILE pCachedFile;
401	/** The number of bytes we've hashed. */
402	KU32 cbHashed;
403	/** Set if this has gone wrong. */
404	KBOOL fGoneBad;
405	/** Set if we're in fallback mode (file not cached). */
406	KBOOL fFallbackMode;
407	/** Set if we've already finalized the digest. */
408	KBOOL fFinal;
409	/** The MD5 fallback context. */
410	struct MD5Context Md5Ctx;
411	/** The finalized digest. */
412	KU8 abDigest[16];
413
414	} KWHASHMD5;
415	/** Magic value for KWHASHMD5::uMagic (Les McCann). */
416	# define KWHASHMD5_MAGIC KUPTR_C(0x19350923)
417
418	#endif /* WITH_HASH_MD5_CACHE */
419	#ifdef WITH_TEMP_MEMORY_FILES
420
421	typedef struct KWFSTEMPFILESEG *PKWFSTEMPFILESEG;
422	typedef struct KWFSTEMPFILESEG
423	{
424	/** File offset of data. */
425	KU32 offData;
426	/** The size of the buffer pbData points to. */
427	KU32 cbDataAlloc;
428	/** The segment data. */
429	KU8 *pbData;
430	} KWFSTEMPFILESEG;
431
432	typedef struct KWFSTEMPFILE *PKWFSTEMPFILE;
433	typedef struct KWFSTEMPFILE
434	{
435	/** Pointer to the next temporary file for this run. */
436	PKWFSTEMPFILE pNext;
437	/** The UTF-16 path. (Allocated after this structure.) */
438	const wchar_t *pwszPath;
439	/** The path length. */
440	KU16 cwcPath;
441	/** Number of active handles using this file/mapping (<= 2). */
442	KU8 cActiveHandles;
443	/** Number of active mappings (mapped views) (0 or 1). */
444	KU8 cMappings;
445	/** The amount of space allocated in the segments. */
446	KU32 cbFileAllocated;
447	/** The current file size. */
448	KU32 cbFile;
449	/** The number of segments. */
450	KU32 cSegs;
451	/** Segments making up the file. */
452	PKWFSTEMPFILESEG paSegs;
453	} KWFSTEMPFILE;
454
455	#endif /* WITH_TEMP_MEMORY_FILES */
456	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
457
458	/**
459	* Console line buffer or output full buffer.
460	*/
461	typedef struct KWOUTPUTSTREAMBUF
462	{
463	/** The main output handle. */
464	HANDLE hOutput;
465	/** Our backup handle. */
466	HANDLE hBackup;
467	/** Set if this is a console handle and we're in line buffered mode.
468	* When clear, we may buffer multiple lines, though try flush on line
469	* boundraries when ever possible. */
470	KBOOL fIsConsole;
471	/** Compressed GetFileType result. */
472	KU8 fFileType;
473	KU8 abPadding[2];
474	union
475	{
476	/** Line buffer mode (fIsConsole == K_TRUE). */
477	struct
478	{
479	/** Amount of pending console output in wchar_t's. */
480	KU32 cwcBuf;
481	/** The allocated buffer size. */
482	KU32 cwcBufAlloc;
483	/** Pending console output. */
484	wchar_t *pwcBuf;
485	} Con;
486	/** Fully buffered mode (fIsConsole == K_FALSE). */
487	struct
488	{
489	/** Amount of pending output (in chars). */
490	KU32 cchBuf;
491	#ifdef WITH_STD_OUT_ERR_BUFFERING
492	/** The allocated buffer size (in chars). */
493	KU32 cchBufAlloc;
494	/** Pending output. */
495	char *pchBuf;
496	#endif
497	} Fully;
498	} u;
499	} KWOUTPUTSTREAMBUF;
500	/** Pointer to a console line buffer. */
501	typedef KWOUTPUTSTREAMBUF *PKWOUTPUTSTREAMBUF;
502
503	/**
504	* Combined console buffer of complete lines.
505	*/
506	typedef struct KWCONSOLEOUTPUT
507	{
508	/** The console output handle.
509	* INVALID_HANDLE_VALUE if we haven't got a console and shouldn't be doing any
510	* combined output buffering. */
511	HANDLE hOutput;
512	/** The current code page for the console. */
513	KU32 uCodepage;
514	/** Amount of pending console output in wchar_t's. */
515	KU32 cwcBuf;
516	/** Number of times we've flushed it in any way (for cl.exe hack). */
517	KU32 cFlushes;
518	/** Pending console output. */
519	wchar_t wszBuf[8192];
520	} KWCONSOLEOUTPUT;
521	/** Pointer to a combined console buffer. */
522	typedef KWCONSOLEOUTPUT *PKWCONSOLEOUTPUT;
523
524	#endif /* WITH_CONSOLE_OUTPUT_BUFFERING */
525
526	/** Handle type. */
527	typedef enum KWHANDLETYPE
528	{
529	KWHANDLETYPE_INVALID = 0,
530	KWHANDLETYPE_FSOBJ_READ_CACHE,
531	KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING,
532	KWHANDLETYPE_TEMP_FILE,
533	KWHANDLETYPE_TEMP_FILE_MAPPING,
534	KWHANDLETYPE_OUTPUT_BUF
535	} KWHANDLETYPE;
536
537	/** Handle data. */
538	typedef struct KWHANDLE
539	{
540	KWHANDLETYPE enmType;
541	/** Number of references */
542	KU32 cRefs;
543	/** The current file offset. */
544	KU32 offFile;
545	/** Handle access. */
546	KU32 dwDesiredAccess;
547	/** The handle. */
548	HANDLE hHandle;
549
550	/** Type specific data. */
551	union
552	{
553	/** The file system object. */
554	PKFSWCACHEDFILE pCachedFile;
555	/** Temporary file handle or mapping handle. */
556	PKWFSTEMPFILE pTempFile;
557	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
558	/** Buffered output stream. */
559	PKWOUTPUTSTREAMBUF pOutBuf;
560	#endif
561	} u;
562	} KWHANDLE;
563	typedef KWHANDLE *PKWHANDLE;
564
565	/**
566	* Tracking one of our memory mappings.
567	*/
568	typedef struct KWMEMMAPPING
569	{
570	/** Number of references. */
571	KU32 cRefs;
572	/** The mapping type (KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING or
573	* KWHANDLETYPE_TEMP_FILE_MAPPING). */
574	KWHANDLETYPE enmType;
575	/** The mapping address. */
576	PVOID pvMapping;
577	/** Type specific data. */
578	union
579	{
580	/** The file system object. */
581	PKFSWCACHEDFILE pCachedFile;
582	/** Temporary file handle or mapping handle. */
583	PKWFSTEMPFILE pTempFile;
584	} u;
585	} KWMEMMAPPING;
586	/** Pointer to a memory mapping tracker. */
587	typedef KWMEMMAPPING *PKWMEMMAPPING;
588
589
590	/** Pointer to a VirtualAlloc tracker entry. */
591	typedef struct KWVIRTALLOC *PKWVIRTALLOC;
592	/**
593	* Tracking an VirtualAlloc allocation.
594	*/
595	typedef struct KWVIRTALLOC
596	{
597	PKWVIRTALLOC pNext;
598	void *pvAlloc;
599	KSIZE cbAlloc;
600	/** This is KU32_MAX if not a preallocated chunk. */
601	KU32 idxPreAllocated;
602	} KWVIRTALLOC;
603
604
605	/** Pointer to a heap (HeapCreate) tracker entry. */
606	typedef struct KWHEAP *PKWHEAP;
607	/**
608	* Tracking an heap (HeapCreate)
609	*/
610	typedef struct KWHEAP
611	{
612	PKWHEAP pNext;
613	HANDLE hHeap;
614	} KWHEAP;
615
616
617	/** Pointer to a FlsAlloc/TlsAlloc tracker entry. */
618	typedef struct KWLOCALSTORAGE *PKWLOCALSTORAGE;
619	/**
620	* Tracking an FlsAlloc/TlsAlloc index.
621	*/
622	typedef struct KWLOCALSTORAGE
623	{
624	PKWLOCALSTORAGE pNext;
625	KU32 idx;
626	} KWLOCALSTORAGE;
627
628
629	/** Pointer to an at exit callback record */
630	typedef struct KWEXITCALLACK *PKWEXITCALLACK;
631	/**
632	* At exit callback record.
633	*/
634	typedef struct KWEXITCALLACK
635	{
636	PKWEXITCALLACK pNext;
637	_onexit_t pfnCallback;
638	/** At exit doesn't have an exit code. */
639	KBOOL fAtExit;
640	} KWEXITCALLACK;
641
642
643	typedef enum KWTOOLTYPE
644	{
645	KWTOOLTYPE_INVALID = 0,
646	KWTOOLTYPE_SANDBOXED,
647	KWTOOLTYPE_WATCOM,
648	KWTOOLTYPE_EXEC,
649	KWTOOLTYPE_END
650	} KWTOOLTYPE;
651
652	typedef enum KWTOOLHINT
653	{
654	KWTOOLHINT_INVALID = 0,
655	KWTOOLHINT_NONE,
656	KWTOOLHINT_VISUAL_CPP_CL,
657	KWTOOLHINT_VISUAL_CPP_LINK,
658	KWTOOLHINT_END
659	} KWTOOLHINT;
660
661
662	/**
663	* A kWorker tool.
664	*/
665	typedef struct KWTOOL
666	{
667	/** The user data core structure. */
668	KFSUSERDATA Core;
669
670	/** The normalized path to the program. */
671	const char *pszPath;
672	/** UTF-16 version of pszPath. */
673	wchar_t const *pwszPath;
674	/** The kind of tool. */
675	KWTOOLTYPE enmType;
676
677	union
678	{
679	struct
680	{
681	/** The main entry point. */
682	KUPTR uMainAddr;
683	/** The executable. */
684	PKWMODULE pExe;
685	/** List of dynamically loaded modules.
686	* These will be kept loaded till the tool is destroyed (if we ever do that). */
687	PKWDYNLOAD pDynLoadHead;
688	/** Module array sorted by hOurMod. */
689	PKWMODULE *papModules;
690	/** Number of entries in papModules. */
691	KU32 cModules;
692
693	/** Tool hint (for hacks and such). */
694	KWTOOLHINT enmHint;
695	} Sandboxed;
696	} u;
697	} KWTOOL;
698	/** Pointer to a tool. */
699	typedef struct KWTOOL *PKWTOOL;
700
701
702	typedef struct KWSANDBOX *PKWSANDBOX;
703	typedef struct KWSANDBOX
704	{
705	/** The tool currently running in the sandbox. */
706	PKWTOOL pTool;
707	/** Jump buffer. */
708	jmp_buf JmpBuf;
709	/** The thread ID of the main thread (owner of JmpBuf). */
710	DWORD idMainThread;
711	/** Copy of the NT TIB of the main thread. */
712	NT_TIB TibMainThread;
713	/** The NT_TIB::ExceptionList value inside the try case.
714	* We restore this prior to the longjmp. */
715	void *pOutXcptListHead;
716	/** The exit code in case of longjmp. */
717	int rcExitCode;
718	/** Set if we're running. */
719	KBOOL fRunning;
720	/** Whether to disable caching of ".pch" files. */
721	KBOOL fNoPchCaching;
722
723	/** The command line. */
724	char *pszCmdLine;
725	/** The UTF-16 command line. */
726	wchar_t *pwszCmdLine;
727	/** Number of arguments in papszArgs. */
728	int cArgs;
729	/** The argument vector. */
730	char **papszArgs;
731	/** The argument vector. */
732	wchar_t **papwszArgs;
733
734	/** The _pgmptr msvcrt variable. */
735	char *pgmptr;
736	/** The _wpgmptr msvcrt variable. */
737	wchar_t *wpgmptr;
738
739	/** The _initenv msvcrt variable. */
740	char **initenv;
741	/** The _winitenv msvcrt variable. */
742	wchar_t **winitenv;
743
744	/** Size of the array we've allocated (ASSUMES nobody messes with it!). */
745	KSIZE cEnvVarsAllocated;
746	/** The _environ msvcrt variable. */
747	char **environ;
748	/** The _wenviron msvcrt variable. */
749	wchar_t **wenviron;
750	/** The shadow _environ msvcrt variable. */
751	char **papszEnvVars;
752	/** The shadow _wenviron msvcrt variable. */
753	wchar_t **papwszEnvVars;
754
755
756	/** Handle table. */
757	PKWHANDLE *papHandles;
758	/** Size of the handle table. */
759	KU32 cHandles;
760	/** Number of active handles in the table. */
761	KU32 cActiveHandles;
762	/** Number of handles in the handle table that will not be freed. */
763	KU32 cFixedHandles;
764	/** Total number of leaked handles. */
765	KU32 cLeakedHandles;
766
767	/** Number of active memory mappings in paMemMappings. */
768	KU32 cMemMappings;
769	/** The allocated size of paMemMappings. */
770	KU32 cMemMappingsAlloc;
771	/** Memory mappings (MapViewOfFile / UnmapViewOfFile). */
772	PKWMEMMAPPING paMemMappings;
773
774	/** Head of the list of temporary file. */
775	PKWFSTEMPFILE pTempFileHead;
776
777	/** Head of the virtual alloc allocations. */
778	PKWVIRTALLOC pVirtualAllocHead;
779	/** Head of the heap list (HeapCreate).
780	* This is only done from images we forcibly restore. */
781	PKWHEAP pHeapHead;
782	/** Head of the FlsAlloc indexes. */
783	PKWLOCALSTORAGE pFlsAllocHead;
784	/** Head of the TlsAlloc indexes. */
785	PKWLOCALSTORAGE pTlsAllocHead;
786
787	/** The at exit callback head.
788	* This is only done from images we forcibly restore. */
789	PKWEXITCALLACK pExitCallbackHead;
790
791	MY_UNICODE_STRING SavedCommandLine;
792
793	#ifdef WITH_HASH_MD5_CACHE
794	/** The special MD5 hash instance. */
795	PKWHASHMD5 pHashHead;
796	/** ReadFile sets these while CryptHashData claims and clears them.
797	*
798	* This is part of the heuristics we use for MD5 caching for header files. The
799	* observed pattern is that c1.dll/c1xx.dll first reads a chunk of a source or
800	* header, then passes the same buffer and read byte count to CryptHashData.
801	*/
802	struct
803	{
804	/** The cached file last read from. */
805	PKFSWCACHEDFILE pCachedFile;
806	/** The file offset of the last cached read. */
807	KU32 offRead;
808	/** The number of bytes read last. */
809	KU32 cbRead;
810	/** The buffer pointer of the last read. */
811	void *pvRead;
812	} LastHashRead;
813	#endif
814
815	#ifdef WITH_CRYPT_CTX_REUSE
816	/** Reusable crypt contexts. */
817	struct
818	{
819	/** The creation provider type. */
820	KU32 dwProvType;
821	/** The creation flags. */
822	KU32 dwFlags;
823	/** The length of the container name. */
824	KU32 cwcContainer;
825	/** The length of the provider name. */
826	KU32 cwcProvider;
827	/** The container name string. */
828	wchar_t *pwszContainer;
829	/** The provider name string. */
830	wchar_t *pwszProvider;
831	/** The context handle. */
832	HCRYPTPROV hProv;
833	} aCryptCtxs[4];
834	/** Number of reusable crypt conexts in aCryptCtxs. */
835	KU32 cCryptCtxs;
836	#endif
837
838
839	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
840	/** The internal standard output handle. */
841	KWHANDLE HandleStdOut;
842	/** The internal standard error handle. */
843	KWHANDLE HandleStdErr;
844	/** Standard output (and whatever else) buffer. */
845	KWOUTPUTSTREAMBUF StdOut;
846	/** Standard error buffer. */
847	KWOUTPUTSTREAMBUF StdErr;
848	/** Combined buffer of completed lines. */
849	KWCONSOLEOUTPUT Combined;
850	#endif
851	} KWSANDBOX;
852
853	/** Replacement function entry. */
854	typedef struct KWREPLACEMENTFUNCTION
855	{
856	/** The function name. */
857	const char *pszFunction;
858	/** The length of the function name. */
859	KSIZE cchFunction;
860	/** The module name (optional). */
861	const char *pszModule;
862	/** The replacement function or data address. */
863	KUPTR pfnReplacement;
864	/** Only replace in the executable.
865	* @todo fix the reinitialization of non-native DLLs! */
866	KBOOL fOnlyExe;
867	} KWREPLACEMENTFUNCTION;
868	typedef KWREPLACEMENTFUNCTION const *PCKWREPLACEMENTFUNCTION;
869
870	#if 0
871	/** Replacement function entry. */
872	typedef struct KWREPLACEMENTDATA
873	{
874	/** The function name. */
875	const char *pszFunction;
876	/** The length of the function name. */
877	KSIZE cchFunction;
878	/** The module name (optional). */
879	const char *pszModule;
880	/** Function providing the replacement. */
881	KUPTR (pfnMakeReplacement)(PKWMODULE pMod, const char pchSymbol, KSIZE cchSymbol);
882	} KWREPLACEMENTDATA;
883	typedef KWREPLACEMENTDATA const *PCKWREPLACEMENTDATA;
884	#endif
885
886
887	/*********************************************************************************************************************************
888	* Global Variables *
889	*********************************************************************************************************************************/
890	/** The sandbox data. */
891	static KWSANDBOX g_Sandbox;
892
893	/** The module currently occupying g_abDefLdBuf. */
894	static PKWMODULE g_pModInLdBuf = NULL;
895
896	/** The module that previuosly occupied g_abDefLdBuf. */
897	static PKWMODULE g_pModPrevInLdBuf = NULL;
898
899	/** Module hash table. */
900	static PKWMODULE g_apModules[127];
901
902	/** GetModuleHandle cache. */
903	static KWGETMODULEHANDLECACHE g_aGetModuleHandleCache[] =
904	{
905	#define MOD_CACHE_STRINGS(str) str, sizeof(str) - 1, (sizeof(L##str) / sizeof(wchar_t)) - 1, L##str
906	{ MOD_CACHE_STRINGS("KERNEL32.DLL"), NULL },
907	{ MOD_CACHE_STRINGS("mscoree.dll"), NULL },
908	};
909
910	/** Module pending TLS allocation. See kwLdrModuleCreateNonNativeSetupTls. */
911	static PKWMODULE g_pModPendingTlsAlloc = NULL;
912
913
914	/** The file system cache. */
915	static PKFSCACHE g_pFsCache;
916	/** The current directory (referenced). */
917	static PKFSOBJ g_pCurDirObj = NULL;
918	#ifdef KBUILD_OS_WINDOWS
919	/** The windows system32 directory (referenced). */
920	static PKFSDIR g_pWinSys32 = NULL;
921	#endif
922
923	/** Verbosity level. */
924	static int g_cVerbose = 2;
925
926	/** Whether we should restart the worker. */
927	static KBOOL g_fRestart = K_FALSE;
928
929	/** Whether control-C/SIGINT or Control-Break/SIGBREAK have been seen. */
930	static KBOOL volatile g_fCtrlC = K_FALSE;
931
932	/* Further down. */
933	extern KWREPLACEMENTFUNCTION const g_aSandboxReplacements[];
934	extern KU32 const g_cSandboxReplacements;
935
936	extern KWREPLACEMENTFUNCTION const g_aSandboxNativeReplacements[];
937	extern KU32 const g_cSandboxNativeReplacements;
938
939	extern KWREPLACEMENTFUNCTION const g_aSandboxGetProcReplacements[];
940	extern KU32 const g_cSandboxGetProcReplacements;
941
942
943	/** Create a larget BSS blob that with help of /IMAGEBASE:0x10000 should
944	* cover the default executable link address of 0x400000.
945	* @remarks Early main() makes it read+write+executable. Attempts as having
946	* it as a separate section failed because the linker insists on
947	* writing out every zero in the uninitialized section, resulting in
948	* really big binaries. */
949	__declspec(align(0x1000))
950	static KU8 g_abDefLdBuf[1610241024];
951
952	#ifdef WITH_LOG_FILE
953	/** Log file handle. */
954	static HANDLE g_hLogFile = INVALID_HANDLE_VALUE;
955	#endif
956
957
958	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
959	/** Virtual address space reserved for CL.EXE heap manager.
960	*
961	* Visual C++ 2010 reserves a 78MB chunk of memory from cl.exe at a fixed
962	* address. It's among other things used for precompiled headers, which
963	* seemingly have addresses hardcoded into them and won't work if mapped
964	* elsewhere. Thus, we have to make sure the area is available when cl.exe asks
965	* for it. (The /Zm option may affect this allocation.)
966	*/
967	static struct
968	{
969	/** The memory address we need. */
970	KUPTR const uFixed;
971	/** How much we need to fix. */
972	KSIZE const cbFixed;
973	/** What we actually got, NULL if given back. */
974	void *pvReserved;
975	/** Whether it is in use or not. */
976	KBOOL fInUse;
977	} g_aFixedVirtualAllocs[] =
978	{
979	# if K_ARCH == K_ARCH_X86_32
980	/* Visual C++ 2010 reserves 0x04b00000 by default, and Visual C++ 2015 reserves
981	0x05300000. We get 0x0f000000 to handle large precompiled header files. */
982	{ KUPTR_C( 0x11000000), KSIZE_C( 0x0f000000), NULL },
983	# else
984	{ KUPTR_C(0x000006BB00000000), KSIZE_C(0x000000002EE00000), NULL },
985	# endif
986	};
987	#endif
988
989
990	#ifdef WITH_HISTORY
991	/** The job history. */
992	static char *g_apszHistory[32];
993	/** Index of the next history entry. */
994	static unsigned g_iHistoryNext = 0;
995	#endif
996
997
998	/** Number of jobs executed. */
999	static KU32 g_cJobs;
1000	/** Number of tools. */
1001	static KU32 g_cTools;
1002	/** Number of modules. */
1003	static KU32 g_cModules;
1004	/** Number of non-native modules. */
1005	static KU32 g_cNonNativeModules;
1006	/** Number of read-cached files. */
1007	static KU32 g_cReadCachedFiles;
1008	/** Total size of read-cached files. */
1009	static KSIZE g_cbReadCachedFiles;
1010
1011	/** Total number of ReadFile calls. */
1012	static KSIZE g_cReadFileCalls;
1013	/** Total bytes read via ReadFile. */
1014	static KSIZE g_cbReadFileTotal;
1015	/** Total number of read from read-cached files. */
1016	static KSIZE g_cReadFileFromReadCached;
1017	/** Total bytes read from read-cached files. */
1018	static KSIZE g_cbReadFileFromReadCached;
1019	/** Total number of read from in-memory temporary files. */
1020	static KSIZE g_cReadFileFromInMemTemp;
1021	/** Total bytes read from in-memory temporary files. */
1022	static KSIZE g_cbReadFileFromInMemTemp;
1023
1024	/** Total number of WriteFile calls. */
1025	static KSIZE g_cWriteFileCalls;
1026	/** Total bytes written via WriteFile. */
1027	static KSIZE g_cbWriteFileTotal;
1028	/** Total number of written to from in-memory temporary files. */
1029	static KSIZE g_cWriteFileToInMemTemp;
1030	/** Total bytes written to in-memory temporary files. */
1031	static KSIZE g_cbWriteFileToInMemTemp;
1032
1033
1034	/*********************************************************************************************************************************
1035	* Internal Functions *
1036	*********************************************************************************************************************************/
1037	static FNKLDRMODGETIMPORT kwLdrModuleGetImportCallback;
1038	static int kwLdrModuleResolveAndLookup(const char *pszName, PKWMODULE pExe, PKWMODULE pImporter,
1039	const char pszSearchPath, PKWMODULE ppMod);
1040	static KBOOL kwSandboxHandleTableEnter(PKWSANDBOX pSandbox, PKWHANDLE pHandle, HANDLE hHandle);
1041	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
1042	static void kwSandboxConsoleWriteA(PKWSANDBOX pSandbox, PKWOUTPUTSTREAMBUF pLineBuf, const char *pchBuffer, KU32 cchToWrite);
1043	#endif
1044	static PPEB kwSandboxGetProcessEnvironmentBlock(void);
1045
1046
1047
1048
1049	/**
1050	* Debug printing.
1051	* @param pszFormat Debug format string.
1052	* @param ... Format argument.
1053	*/
1054	static void kwDbgPrintfV(const char *pszFormat, va_list va)
1055	{
1056	if (g_cVerbose >= 2)
1057	{
1058	DWORD const dwSavedErr = GetLastError();
1059	#ifdef WITH_LOG_FILE
1060	DWORD dwIgnored;
1061	char szTmp[2048];
1062	int cchPrefix = _snprintf(szTmp, sizeof(szTmp), "%x:%x: ", GetCurrentProcessId(), GetCurrentThreadId());
1063	int cch = vsnprintf(&szTmp[cchPrefix], sizeof(szTmp) - cchPrefix, pszFormat, va);
1064	if (cch < (int)sizeof(szTmp) - 1 - cchPrefix)
1065	cch += cchPrefix;
1066	else
1067	{
1068	cch = sizeof(szTmp) - 1;
1069	szTmp[cch] = '\0';
1070	}
1071
1072	if (g_hLogFile == INVALID_HANDLE_VALUE)
1073	{
1074	wchar_t wszFilename[128];
1075	_snwprintf(wszFilename, K_ELEMENTS(wszFilename), L"kWorker-%x-%x.log", GetTickCount(), GetCurrentProcessId());
1076	g_hLogFile = CreateFileW(wszFilename, GENERIC_WRITE, FILE_SHARE_READ, NULL /pSecAttrs/, CREATE_ALWAYS,
1077	FILE_ATTRIBUTE_NORMAL, NULL /hTemplateFile/);
1078	}
1079
1080	WriteFile(g_hLogFile, szTmp, cch, &dwIgnored, NULL /pOverlapped/);
1081	#else
1082	fprintf(stderr, "debug: ");
1083	vfprintf(stderr, pszFormat, va);
1084	#endif
1085
1086	SetLastError(dwSavedErr);
1087	}
1088	}
1089
1090
1091	/**
1092	* Debug printing.
1093	* @param pszFormat Debug format string.
1094	* @param ... Format argument.
1095	*/
1096	static void kwDbgPrintf(const char *pszFormat, ...)
1097	{
1098	if (g_cVerbose >= 2)
1099	{
1100	va_list va;
1101	va_start(va, pszFormat);
1102	kwDbgPrintfV(pszFormat, va);
1103	va_end(va);
1104	}
1105	}
1106
1107
1108	/**
1109	* Debugger printing.
1110	* @param pszFormat Debug format string.
1111	* @param ... Format argument.
1112	*/
1113	static void kwDebuggerPrintfV(const char *pszFormat, va_list va)
1114	{
1115	if (IsDebuggerPresent())
1116	{
1117	DWORD const dwSavedErr = GetLastError();
1118	char szTmp[2048];
1119
1120	_vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
1121	OutputDebugStringA(szTmp);
1122
1123	SetLastError(dwSavedErr);
1124	}
1125	}
1126
1127
1128	/**
1129	* Debugger printing.
1130	* @param pszFormat Debug format string.
1131	* @param ... Format argument.
1132	*/
1133	static void kwDebuggerPrintf(const char *pszFormat, ...)
1134	{
1135	va_list va;
1136	va_start(va, pszFormat);
1137	kwDebuggerPrintfV(pszFormat, va);
1138	va_end(va);
1139	}
1140
1141
1142
1143	/**
1144	* Error printing.
1145	* @param pszFormat Message format string.
1146	* @param ... Format argument.
1147	*/
1148	static void kwErrPrintfV(const char *pszFormat, va_list va)
1149	{
1150	DWORD const dwSavedErr = GetLastError();
1151
1152	fprintf(stderr, "kWorker: error: ");
1153	vfprintf(stderr, pszFormat, va);
1154
1155	SetLastError(dwSavedErr);
1156	}
1157
1158
1159	/**
1160	* Error printing.
1161	* @param pszFormat Message format string.
1162	* @param ... Format argument.
1163	*/
1164	static void kwErrPrintf(const char *pszFormat, ...)
1165	{
1166	va_list va;
1167	va_start(va, pszFormat);
1168	kwErrPrintfV(pszFormat, va);
1169	va_end(va);
1170	}
1171
1172
1173	/**
1174	* Error printing.
1175	* @return rc;
1176	* @param rc Return value
1177	* @param pszFormat Message format string.
1178	* @param ... Format argument.
1179	*/
1180	static int kwErrPrintfRc(int rc, const char *pszFormat, ...)
1181	{
1182	va_list va;
1183	va_start(va, pszFormat);
1184	kwErrPrintfV(pszFormat, va);
1185	va_end(va);
1186	return rc;
1187	}
1188
1189
1190	#ifdef K_STRICT
1191
1192	KHLP_DECL(void) kHlpAssertMsg1(const char pszExpr, const char pszFile, unsigned iLine, const char *pszFunction)
1193	{
1194	DWORD const dwSavedErr = GetLastError();
1195
1196	fprintf(stderr,
1197	"\n"
1198	"!!Assertion failed!!\n"
1199	"Expression: %s\n"
1200	"Function : %s\n"
1201	"File: %s\n"
1202	"Line: %d\n"
1203	, pszExpr, pszFunction, pszFile, iLine);
1204
1205	SetLastError(dwSavedErr);
1206	}
1207
1208
1209	KHLP_DECL(void) kHlpAssertMsg2(const char *pszFormat, ...)
1210	{
1211	DWORD const dwSavedErr = GetLastError();
1212	va_list va;
1213
1214	va_start(va, pszFormat);
1215	fprintf(stderr, pszFormat, va);
1216	va_end(va);
1217
1218	SetLastError(dwSavedErr);
1219	}
1220
1221	#endif /* K_STRICT */
1222
1223
1224	/**
1225	* Hashes a string.
1226	*
1227	* @returns 32-bit string hash.
1228	* @param pszString String to hash.
1229	*/
1230	static KU32 kwStrHash(const char *pszString)
1231	{
1232	/* This algorithm was created for sdbm (a public-domain reimplementation of
1233	ndbm) database library. it was found to do well in scrambling bits,
1234	causing better distribution of the keys and fewer splits. it also happens
1235	to be a good general hashing function with good distribution. the actual
1236	function is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
1237	is the faster version used in gawk. [there is even a faster, duff-device
1238	version] the magic constant 65599 was picked out of thin air while
1239	experimenting with different constants, and turns out to be a prime.
1240	this is one of the algorithms used in berkeley db (see sleepycat) and
1241	elsewhere. */
1242	KU32 uHash = 0;
1243	KU32 uChar;
1244	while ((uChar = (unsigned char)*pszString++) != 0)
1245	uHash = uChar + (uHash << 6) + (uHash << 16) - uHash;
1246	return uHash;
1247	}
1248
1249
1250	/**
1251	* Hashes a string.
1252	*
1253	* @returns The string length.
1254	* @param pszString String to hash.
1255	* @param puHash Where to return the 32-bit string hash.
1256	*/
1257	static KSIZE kwStrHashEx(const char pszString, KU32 puHash)
1258	{
1259	const char * const pszStart = pszString;
1260	KU32 uHash = 0;
1261	KU32 uChar;
1262	while ((uChar = (unsigned char)*pszString) != 0)
1263	{
1264	uHash = uChar + (uHash << 6) + (uHash << 16) - uHash;
1265	pszString++;
1266	}
1267	*puHash = uHash;
1268	return pszString - pszStart;
1269	}
1270
1271
1272	/**
1273	* Hashes a string.
1274	*
1275	* @returns The string length in wchar_t units.
1276	* @param pwszString String to hash.
1277	* @param puHash Where to return the 32-bit string hash.
1278	*/
1279	static KSIZE kwUtf16HashEx(const wchar_t pwszString, KU32 puHash)
1280	{
1281	const wchar_t * const pwszStart = pwszString;
1282	KU32 uHash = 0;
1283	KU32 uChar;
1284	while ((uChar = *pwszString) != 0)
1285	{
1286	uHash = uChar + (uHash << 6) + (uHash << 16) - uHash;
1287	pwszString++;
1288	}
1289	*puHash = uHash;
1290	return pwszString - pwszStart;
1291	}
1292
1293
1294	/**
1295	* Converts the given string to unicode.
1296	*
1297	* @returns Length of the resulting string in wchar_t's.
1298	* @param pszSrc The source string.
1299	* @param pwszDst The destination buffer.
1300	* @param cwcDst The size of the destination buffer in wchar_t's.
1301	*/
1302	static KSIZE kwStrToUtf16(const char pszSrc, wchar_t pwszDst, KSIZE cwcDst)
1303	{
1304	/* Just to the quick ASCII stuff for now. correct ansi code page stuff later some time. */
1305	KSIZE offDst = 0;
1306	while (offDst < cwcDst)
1307	{
1308	char ch = *pszSrc++;
1309	pwszDst[offDst++] = ch;
1310	if (!ch)
1311	return offDst - 1;
1312	kHlpAssert((unsigned)ch < 127);
1313	}
1314
1315	pwszDst[offDst - 1] = '\0';
1316	return offDst;
1317	}
1318
1319
1320	/**
1321	* Converts the given string to UTF-16, allocating the buffer.
1322	*
1323	* @returns Pointer to the new heap allocation containing the UTF-16 version of
1324	* the source string.
1325	* @param pchSrc The source string.
1326	* @param cchSrc The length of the source string.
1327	*/
1328	static wchar_t kwStrToUtf16AllocN(const char pchSrc, KSIZE cchSrc)
1329	{
1330	DWORD const dwErrSaved = GetLastError();
1331	KSIZE cwcBuf = cchSrc + 1;
1332	wchar_t pwszBuf = (wchar_t )kHlpAlloc(cwcBuf * sizeof(pwszBuf));
1333	if (pwszBuf)
1334	{
1335	if (cchSrc > 0)
1336	{
1337	int cwcRet = MultiByteToWideChar(CP_ACP, 0, pchSrc, (int)cchSrc, pwszBuf, (int)cwcBuf - 1);
1338	if (cwcRet > 0)
1339	{
1340	kHlpAssert(cwcRet < (KSSIZE)cwcBuf);
1341	pwszBuf[cwcRet] = '\0';
1342	}
1343	else
1344	{
1345	kHlpFree(pwszBuf);
1346
1347	/* Figure the length and allocate the right buffer size. */
1348	SetLastError(NO_ERROR);
1349	cwcRet = MultiByteToWideChar(CP_ACP, 0, pchSrc, (int)cchSrc, pwszBuf, 0);
1350	if (cwcRet)
1351	{
1352	cwcBuf = cwcRet + 2;
1353	pwszBuf = (wchar_t )kHlpAlloc(cwcBuf sizeof(pwszBuf));
1354	if (pwszBuf)
1355	{
1356	SetLastError(NO_ERROR);
1357	cwcRet = MultiByteToWideChar(CP_ACP, 0, pchSrc, (int)cchSrc, pwszBuf, (int)cwcBuf - 1);
1358	if (cwcRet)
1359	{
1360	kHlpAssert(cwcRet < (KSSIZE)cwcBuf);
1361	pwszBuf[cwcRet] = '\0';
1362	}
1363	else
1364	{
1365	kwErrPrintf("MultiByteToWideChar(,,%.s,,) -> dwErr=%d\n", cchSrc, cchSrc, pchSrc, GetLastError());
1366	kHlpFree(pwszBuf);
1367	pwszBuf = NULL;
1368	}
1369	}
1370	}
1371	else
1372	{
1373	kwErrPrintf("MultiByteToWideChar(,,%.s,,NULL,0) -> dwErr=%d\n", cchSrc, cchSrc, pchSrc, GetLastError());
1374	pwszBuf = NULL;
1375	}
1376	}
1377	}
1378	else
1379	pwszBuf[0] = '\0';
1380	}
1381	SetLastError(dwErrSaved);
1382	return pwszBuf;
1383	}
1384
1385
1386	/**
1387	* Converts the given UTF-16 to a normal string.
1388	*
1389	* @returns Length of the resulting string.
1390	* @param pwszSrc The source UTF-16 string.
1391	* @param pszDst The destination buffer.
1392	* @param cbDst The size of the destination buffer in bytes.
1393	*/
1394	static KSIZE kwUtf16ToStr(const wchar_t pwszSrc, char pszDst, KSIZE cbDst)
1395	{
1396	/* Just to the quick ASCII stuff for now. correct ansi code page stuff later some time. */
1397	KSIZE offDst = 0;
1398	while (offDst < cbDst)
1399	{
1400	wchar_t wc = *pwszSrc++;
1401	pszDst[offDst++] = (char)wc;
1402	if (!wc)
1403	return offDst - 1;
1404	kHlpAssert((unsigned)wc < 127);
1405	}
1406
1407	pszDst[offDst - 1] = '\0';
1408	return offDst;
1409	}
1410
1411
1412	/**
1413	* Converts the given UTF-16 to ASSI, allocating the buffer.
1414	*
1415	* @returns Pointer to the new heap allocation containing the ANSI version of
1416	* the source string.
1417	* @param pwcSrc The source string.
1418	* @param cwcSrc The length of the source string.
1419	*/
1420	static char kwUtf16ToStrAllocN(const wchar_t pwcSrc, KSIZE cwcSrc)
1421	{
1422	DWORD const dwErrSaved = GetLastError();
1423	KSIZE cbBuf = cwcSrc + (cwcSrc >> 1) + 1;
1424	char pszBuf = (char )kHlpAlloc(cbBuf);
1425	if (pszBuf)
1426	{
1427	if (cwcSrc > 0)
1428	{
1429	int cchRet = WideCharToMultiByte(CP_ACP, 0, pwcSrc, (int)cwcSrc, pszBuf, (int)cbBuf - 1, NULL, NULL);
1430	if (cchRet > 0)
1431	{
1432	kHlpAssert(cchRet < (KSSIZE)cbBuf);
1433	pszBuf[cchRet] = '\0';
1434	}
1435	else
1436	{
1437	kHlpFree(pszBuf);
1438
1439	/* Figure the length and allocate the right buffer size. */
1440	SetLastError(NO_ERROR);
1441	cchRet = WideCharToMultiByte(CP_ACP, 0, pwcSrc, (int)cwcSrc, pszBuf, 0, NULL, NULL);
1442	if (cchRet)
1443	{
1444	cbBuf = cchRet + 2;
1445	pszBuf = (char *)kHlpAlloc(cbBuf);
1446	if (pszBuf)
1447	{
1448	SetLastError(NO_ERROR);
1449	cchRet = WideCharToMultiByte(CP_ACP, 0, pwcSrc, (int)cwcSrc, pszBuf, (int)cbBuf - 1, NULL, NULL);
1450	if (cchRet)
1451	{
1452	kHlpAssert(cchRet < (KSSIZE)cbBuf);
1453	pszBuf[cchRet] = '\0';
1454	}
1455	else
1456	{
1457	kwErrPrintf("WideCharToMultiByte(,,%.ls,,) -> dwErr=%d\n", cwcSrc, cwcSrc, pwcSrc, GetLastError());
1458	kHlpFree(pszBuf);
1459	pszBuf = NULL;
1460	}
1461	}
1462	}
1463	else
1464	{
1465	kwErrPrintf("WideCharToMultiByte(,,%.ls,,NULL,0) -> dwErr=%d\n", cwcSrc, cwcSrc, pwcSrc, GetLastError());
1466	pszBuf = NULL;
1467	}
1468	}
1469	}
1470	else
1471	pszBuf[0] = '\0';
1472	}
1473	SetLastError(dwErrSaved);
1474	return pszBuf;
1475	}
1476
1477
1478
1479	/** UTF-16 string length. */
1480	static KSIZE kwUtf16Len(wchar_t const *pwsz)
1481	{
1482	KSIZE cwc = 0;
1483	while (*pwsz != '\0')
1484	cwc++, pwsz++;
1485	return cwc;
1486	}
1487
1488	/**
1489	* Copy out the UTF-16 string following the convension of GetModuleFileName
1490	*/
1491	static DWORD kwUtf16CopyStyle1(wchar_t const pwszSrc, wchar_t pwszDst, KSIZE cwcDst)
1492	{
1493	KSIZE cwcSrc = kwUtf16Len(pwszSrc);
1494	if (cwcSrc + 1 <= cwcDst)
1495	{
1496	kHlpMemCopy(pwszDst, pwszSrc, (cwcSrc + 1) * sizeof(wchar_t));
1497	return (DWORD)cwcSrc;
1498	}
1499	if (cwcDst > 0)
1500	{
1501	KSIZE cwcDstTmp = cwcDst - 1;
1502	pwszDst[cwcDstTmp] = '\0';
1503	if (cwcDstTmp > 0)
1504	kHlpMemCopy(pwszDst, pwszSrc, cwcDstTmp);
1505	}
1506	SetLastError(ERROR_INSUFFICIENT_BUFFER);
1507	return (DWORD)cwcDst;
1508	}
1509
1510
1511	/**
1512	* Copy out the ANSI string following the convension of GetModuleFileName
1513	*/
1514	static DWORD kwStrCopyStyle1(char const pszSrc, char pszDst, KSIZE cbDst)
1515	{
1516	KSIZE cchSrc = kHlpStrLen(pszSrc);
1517	if (cchSrc + 1 <= cbDst)
1518	{
1519	kHlpMemCopy(pszDst, pszSrc, cchSrc + 1);
1520	return (DWORD)cchSrc;
1521	}
1522	if (cbDst > 0)
1523	{
1524	KSIZE cbDstTmp = cbDst - 1;
1525	pszDst[cbDstTmp] = '\0';
1526	if (cbDstTmp > 0)
1527	kHlpMemCopy(pszDst, pszSrc, cbDstTmp);
1528	}
1529	SetLastError(ERROR_INSUFFICIENT_BUFFER);
1530	return (DWORD)cbDst;
1531	}
1532
1533
1534	/**
1535	* Normalizes the path so we get a consistent hash.
1536	*
1537	* @returns status code.
1538	* @param pszPath The path.
1539	* @param pszNormPath The output buffer.
1540	* @param cbNormPath The size of the output buffer.
1541	*/
1542	static int kwPathNormalize(const char pszPath, char pszNormPath, KSIZE cbNormPath)
1543	{
1544	KFSLOOKUPERROR enmError;
1545	PKFSOBJ pFsObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
1546	if (pFsObj)
1547	{
1548	KBOOL fRc;
1549	fRc = kFsCacheObjGetFullPathA(pFsObj, pszNormPath, cbNormPath, '\\');
1550	kFsCacheObjRelease(g_pFsCache, pFsObj);
1551	if (fRc)
1552	return 0;
1553	return KERR_BUFFER_OVERFLOW;
1554	}
1555	return KERR_FILE_NOT_FOUND;
1556	}
1557
1558
1559	/**
1560	* Get the pointer to the filename part of the path.
1561	*
1562	* @returns Pointer to where the filename starts within the string pointed to by pszFilename.
1563	* @returns Pointer to the terminator char if no filename.
1564	* @param pszPath The path to parse.
1565	*/
1566	static wchar_t kwPathGetFilenameW(const wchar_t pwszPath)
1567	{
1568	const wchar_t *pwszLast = NULL;
1569	for (;;)
1570	{
1571	wchar_t wc = *pwszPath;
1572	#if K_OS == K_OS_OS2 \|\| K_OS == K_OS_WINDOWS
1573	if (wc == '/' \|\| wc == '\\' \|\| wc == ':')
1574	{
1575	while ((wc = *++pwszPath) == '/' \|\| wc == '\\' \|\| wc == ':')
1576	/* nothing */;
1577	pwszLast = pwszPath;
1578	}
1579	#else
1580	if (wc == '/')
1581	{
1582	while ((wc = *++pszFilename) == '/')
1583	/* betsuni */;
1584	pwszLast = pwszPath;
1585	}
1586	#endif
1587	if (!wc)
1588	return (wchar_t *)(pwszLast ? pwszLast : pwszPath);
1589	pwszPath++;
1590	}
1591	}
1592
1593
1594
1595	/**
1596	* Retains a new reference to the given module
1597	* @returns pMod
1598	* @param pMod The module to retain.
1599	*/
1600	static PKWMODULE kwLdrModuleRetain(PKWMODULE pMod)
1601	{
1602	kHlpAssert(pMod->cRefs > 0);
1603	kHlpAssert(pMod->cRefs < 64);
1604	pMod->cRefs++;
1605	return pMod;
1606	}
1607
1608
1609	/**
1610	* Releases a module reference.
1611	*
1612	* @param pMod The module to release.
1613	*/
1614	static void kwLdrModuleRelease(PKWMODULE pMod)
1615	{
1616	if (--pMod->cRefs == 0)
1617	{
1618	/* Unlink it. */
1619	if (!pMod->fExe)
1620	{
1621	PKWMODULE pPrev = NULL;
1622	unsigned idx = pMod->uHashPath % K_ELEMENTS(g_apModules);
1623	if (g_apModules[idx] == pMod)
1624	g_apModules[idx] = pMod->pNext;
1625	else
1626	{
1627	PKWMODULE pPrev = g_apModules[idx];
1628	kHlpAssert(pPrev != NULL);
1629	while (pPrev->pNext != pMod)
1630	{
1631	pPrev = pPrev->pNext;
1632	kHlpAssert(pPrev != NULL);
1633	}
1634	pPrev->pNext = pMod->pNext;
1635	}
1636	}
1637
1638	/* Release import modules. */
1639	if (!pMod->fNative)
1640	{
1641	KSIZE idx = pMod->u.Manual.cImpMods;
1642	while (idx-- > 0)
1643	if (pMod->u.Manual.apImpMods[idx])
1644	{
1645	kwLdrModuleRelease(pMod->u.Manual.apImpMods[idx]);
1646	pMod->u.Manual.apImpMods[idx] = NULL;
1647	}
1648	}
1649
1650	/* Free our resources. */
1651	kLdrModClose(pMod->pLdrMod);
1652	pMod->pLdrMod = NULL;
1653
1654	if (!pMod->fNative)
1655	{
1656	kHlpPageFree(pMod->u.Manual.pbCopy, pMod->cbImage);
1657	kHlpPageFree(pMod->u.Manual.pbLoad, pMod->cbImage);
1658	}
1659
1660	kHlpFree(pMod);
1661	}
1662	else
1663	kHlpAssert(pMod->cRefs < 64);
1664	}
1665
1666
1667	/**
1668	* Links the module into the module hash table.
1669	*
1670	* @returns pMod
1671	* @param pMod The module to link.
1672	*/
1673	static PKWMODULE kwLdrModuleLink(PKWMODULE pMod)
1674	{
1675	unsigned idx = pMod->uHashPath % K_ELEMENTS(g_apModules);
1676	pMod->pNext = g_apModules[idx];
1677	g_apModules[idx] = pMod;
1678	return pMod;
1679	}
1680
1681
1682	/**
1683	* Replaces imports for this module according to g_aSandboxNativeReplacements.
1684	*
1685	* @param pMod The natively loaded module to process.
1686	*/
1687	static void kwLdrModuleDoNativeImportReplacements(PKWMODULE pMod)
1688	{
1689	KSIZE const cbImage = (KSIZE)kLdrModSize(pMod->pLdrMod);
1690	KU8 const * const pbImage = (KU8 const *)pMod->hOurMod;
1691	IMAGE_DOS_HEADER const pMzHdr = (IMAGE_DOS_HEADER const )pbImage;
1692	IMAGE_NT_HEADERS const *pNtHdrs;
1693	IMAGE_DATA_DIRECTORY const *pDirEnt;
1694
1695	kHlpAssert(pMod->fNative);
1696
1697	/*
1698	* Locate the export descriptors.
1699	*/
1700	/* MZ header. */
1701	if (pMzHdr->e_magic == IMAGE_DOS_SIGNATURE)
1702	{
1703	kHlpAssertReturnVoid((KU32)pMzHdr->e_lfanew <= cbImage - sizeof(*pNtHdrs));
1704	pNtHdrs = (IMAGE_NT_HEADERS const *)&pbImage[pMzHdr->e_lfanew];
1705	}
1706	else
1707	pNtHdrs = (IMAGE_NT_HEADERS const *)pbImage;
1708
1709	/* Check PE header. */
1710	kHlpAssertReturnVoid(pNtHdrs->Signature == IMAGE_NT_SIGNATURE);
1711	kHlpAssertReturnVoid(pNtHdrs->FileHeader.SizeOfOptionalHeader == sizeof(pNtHdrs->OptionalHeader));
1712
1713	/* Locate the import descriptor array. */
1714	pDirEnt = (IMAGE_DATA_DIRECTORY const *)&pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
1715	if ( pDirEnt->Size > 0
1716	&& pDirEnt->VirtualAddress != 0)
1717	{
1718	const IMAGE_IMPORT_DESCRIPTOR pImpDesc = (const IMAGE_IMPORT_DESCRIPTOR )&pbImage[pDirEnt->VirtualAddress];
1719	KU32 cLeft = pDirEnt->Size / sizeof(*pImpDesc);
1720	MEMORY_BASIC_INFORMATION ProtInfo = { NULL, NULL, 0, 0, 0, 0, 0 };
1721	KU8 *pbProtRange = NULL;
1722	SIZE_T cbProtRange = 0;
1723	DWORD fOldProt = 0;
1724	KU32 const cbPage = 0x1000;
1725	BOOL fRc;
1726
1727
1728	kHlpAssertReturnVoid(pDirEnt->VirtualAddress < cbImage);
1729	kHlpAssertReturnVoid(pDirEnt->Size < cbImage);
1730	kHlpAssertReturnVoid(pDirEnt->VirtualAddress + pDirEnt->Size <= cbImage);
1731
1732	/*
1733	* Walk the import descriptor array.
1734	* Note! This only works if there's a backup thunk array, otherwise we cannot get at the name.
1735	*/
1736	while ( cLeft-- > 0
1737	&& pImpDesc->Name > 0
1738	&& pImpDesc->FirstThunk > 0)
1739	{
1740	KU32 iThunk;
1741	const char * const pszImport = (const char *)&pbImage[pImpDesc->Name];
1742	PIMAGE_THUNK_DATA paThunks = (PIMAGE_THUNK_DATA)&pbImage[pImpDesc->FirstThunk];
1743	PIMAGE_THUNK_DATA paOrgThunks = (PIMAGE_THUNK_DATA)&pbImage[pImpDesc->OriginalFirstThunk];
1744	kHlpAssertReturnVoid(pImpDesc->Name < cbImage);
1745	kHlpAssertReturnVoid(pImpDesc->FirstThunk < cbImage);
1746	kHlpAssertReturnVoid(pImpDesc->OriginalFirstThunk < cbImage);
1747	kHlpAssertReturnVoid(pImpDesc->OriginalFirstThunk != pImpDesc->FirstThunk);
1748	kHlpAssertReturnVoid(pImpDesc->OriginalFirstThunk);
1749
1750	/* Iterate the thunks. */
1751	for (iThunk = 0; paOrgThunks[iThunk].u1.Ordinal != 0; iThunk++)
1752	{
1753	KUPTR const off = paOrgThunks[iThunk].u1.Function;
1754	kHlpAssertReturnVoid(off < cbImage);
1755	if (!IMAGE_SNAP_BY_ORDINAL(off))
1756	{
1757	IMAGE_IMPORT_BY_NAME const pName = (IMAGE_IMPORT_BY_NAME const )&pbImage[off];
1758	KSIZE const cchSymbol = kHlpStrLen(pName->Name);
1759	KU32 i = g_cSandboxNativeReplacements;
1760	while (i-- > 0)
1761	if ( g_aSandboxNativeReplacements[i].cchFunction == cchSymbol
1762	&& kHlpMemComp(g_aSandboxNativeReplacements[i].pszFunction, pName->Name, cchSymbol) == 0)
1763	{
1764	if ( !g_aSandboxNativeReplacements[i].pszModule
1765	\|\| kHlpStrICompAscii(g_aSandboxNativeReplacements[i].pszModule, pszImport) == 0)
1766	{
1767	KW_LOG(("%s: replacing %s!%s\n", pMod->pLdrMod->pszName, pszImport, pName->Name));
1768
1769	/* The .rdata section is normally read-only, so we need to make it writable first. */
1770	if ((KUPTR)&paThunks[iThunk] - (KUPTR)pbProtRange >= cbPage)
1771	{
1772	/* Restore previous .rdata page. */
1773	if (fOldProt)
1774	{
1775	fRc = VirtualProtect(pbProtRange, cbProtRange, fOldProt, NULL /pfOldProt/);
1776	kHlpAssert(fRc);
1777	fOldProt = 0;
1778	}
1779
1780	/* Query attributes for the current .rdata page. */
1781	pbProtRange = (KU8 *)((KUPTR)&paThunks[iThunk] & ~(KUPTR)(cbPage - 1));
1782	cbProtRange = VirtualQuery(pbProtRange, &ProtInfo, sizeof(ProtInfo));
1783	kHlpAssert(cbProtRange);
1784	if (cbProtRange)
1785	{
1786	switch (ProtInfo.Protect)
1787	{
1788	case PAGE_READWRITE:
1789	case PAGE_WRITECOPY:
1790	case PAGE_EXECUTE_READWRITE:
1791	case PAGE_EXECUTE_WRITECOPY:
1792	/* Already writable, nothing to do. */
1793	break;
1794
1795	default:
1796	kHlpAssertMsgFailed(("%#x\n", ProtInfo.Protect));
1797	case PAGE_READONLY:
1798	cbProtRange = cbPage;
1799	fRc = VirtualProtect(pbProtRange, cbProtRange, PAGE_READWRITE, &fOldProt);
1800	break;
1801
1802	case PAGE_EXECUTE:
1803	case PAGE_EXECUTE_READ:
1804	cbProtRange = cbPage;
1805	fRc = VirtualProtect(pbProtRange, cbProtRange, PAGE_EXECUTE_READWRITE, &fOldProt);
1806	break;
1807	}
1808	kHlpAssertStmt(fRc, fOldProt = 0);
1809	}
1810	}
1811
1812	paThunks[iThunk].u1.AddressOfData = g_aSandboxNativeReplacements[i].pfnReplacement;
1813	break;
1814	}
1815	}
1816	}
1817	}
1818
1819
1820	/* Next import descriptor. */
1821	pImpDesc++;
1822	}
1823
1824
1825	if (fOldProt)
1826	{
1827	DWORD fIgnore = 0;
1828	fRc = VirtualProtect(pbProtRange, cbProtRange, fOldProt, &fIgnore);
1829	kHlpAssertMsg(fRc, ("%u\n", GetLastError())); K_NOREF(fRc);
1830	}
1831	}
1832
1833	}
1834
1835
1836	/**
1837	* Creates a module from a native kLdr module handle.
1838	*
1839	* @returns Module w/ 1 reference on success, NULL on failure.
1840	* @param pLdrMod The native kLdr module.
1841	* @param pszPath The normalized path to the module.
1842	* @param cbPath The module path length with terminator.
1843	* @param uHashPath The module path hash.
1844	* @param fDoReplacements Whether to do import replacements on this
1845	* module.
1846	*/
1847	static PKWMODULE kwLdrModuleCreateForNativekLdrModule(PKLDRMOD pLdrMod, const char *pszPath, KSIZE cbPath, KU32 uHashPath,
1848	KBOOL fDoReplacements)
1849	{
1850	/*
1851	* Create the entry.
1852	*/
1853	PKWMODULE pMod = (PKWMODULE)kHlpAllocZ(sizeof(pMod) + cbPath + cbPath 2 * sizeof(wchar_t));
1854	if (pMod)
1855	{
1856	pMod->pwszPath = (wchar_t *)(pMod + 1);
1857	kwStrToUtf16(pszPath, (wchar_t )pMod->pwszPath, cbPath 2);
1858	pMod->pszPath = (char )kHlpMemCopy((char )&pMod->pwszPath[cbPath * 2], pszPath, cbPath);
1859	pMod->uHashPath = uHashPath;
1860	pMod->cRefs = 1;
1861	pMod->offFilename = (KU16)(kHlpGetFilename(pszPath) - pszPath);
1862	pMod->fExe = K_FALSE;
1863	pMod->fNative = K_TRUE;
1864	pMod->pLdrMod = pLdrMod;
1865	pMod->hOurMod = (HMODULE)(KUPTR)pLdrMod->aSegments[0].MapAddress;
1866	pMod->cbImage = (KSIZE)kLdrModSize(pLdrMod);
1867
1868	if (fDoReplacements)
1869	{
1870	DWORD const dwSavedErr = GetLastError();
1871	kwLdrModuleDoNativeImportReplacements(pMod);
1872	SetLastError(dwSavedErr);
1873	}
1874
1875	KW_LOG(("New module: %p LB %#010x %s (native)\n",
1876	(KUPTR)pMod->pLdrMod->aSegments[0].MapAddress, kLdrModSize(pMod->pLdrMod), pMod->pszPath));
1877	g_cModules++;
1878	return kwLdrModuleLink(pMod);
1879	}
1880	return NULL;
1881	}
1882
1883
1884
1885	/**
1886	* Creates a module using the native loader.
1887	*
1888	* @returns Module w/ 1 reference on success, NULL on failure.
1889	* @param pszPath The normalized path to the module.
1890	* @param uHashPath The module path hash.
1891	* @param fDoReplacements Whether to do import replacements on this
1892	* module.
1893	*/
1894	static PKWMODULE kwLdrModuleCreateNative(const char *pszPath, KU32 uHashPath, KBOOL fDoReplacements)
1895	{
1896	/*
1897	* Open the module and check the type.
1898	*/
1899	PKLDRMOD pLdrMod;
1900	int rc = kLdrModOpenNative(pszPath, &pLdrMod);
1901	if (rc == 0)
1902	{
1903	PKWMODULE pMod = kwLdrModuleCreateForNativekLdrModule(pLdrMod, pszPath, kHlpStrLen(pszPath) + 1,
1904	uHashPath, fDoReplacements);
1905	if (pMod)
1906	return pMod;
1907	kLdrModClose(pLdrMod);
1908	}
1909	return NULL;
1910	}
1911
1912
1913	/**
1914	* Sets up the quick zero & copy tables for the non-native module.
1915	*
1916	* This is a worker for kwLdrModuleCreateNonNative.
1917	*
1918	* @param pMod The module.
1919	*/
1920	static void kwLdrModuleCreateNonNativeSetupQuickZeroAndCopy(PKWMODULE pMod)
1921	{
1922	PCKLDRSEG paSegs = pMod->pLdrMod->aSegments;
1923	KU32 cSegs = pMod->pLdrMod->cSegments;
1924	KU32 iSeg;
1925
1926	KWLDR_LOG(("Setting up quick zero & copy for %s:\n", pMod->pszPath));
1927	pMod->u.Manual.cQuickCopyChunks = 0;
1928	pMod->u.Manual.cQuickZeroChunks = 0;
1929
1930	for (iSeg = 0; iSeg < cSegs; iSeg++)
1931	switch (paSegs[iSeg].enmProt)
1932	{
1933	case KPROT_READWRITE:
1934	case KPROT_WRITECOPY:
1935	case KPROT_EXECUTE_READWRITE:
1936	case KPROT_EXECUTE_WRITECOPY:
1937	if (paSegs[iSeg].cbMapped)
1938	{
1939	KU32 iChunk = pMod->u.Manual.cQuickCopyChunks;
1940	if (iChunk < K_ELEMENTS(pMod->u.Manual.aQuickCopyChunks))
1941	{
1942	/*
1943	* Check for trailing zero words.
1944	*/
1945	KSIZE cbTrailingZeros;
1946	if ( paSegs[iSeg].cbMapped >= 64 * 2 * sizeof(KSIZE)
1947	&& (paSegs[iSeg].cbMapped & 7) == 0
1948	&& pMod->u.Manual.cQuickZeroChunks < K_ELEMENTS(pMod->u.Manual.aQuickZeroChunks) )
1949	{
1950	KSIZE const pauNatural = (KSIZE const )&pMod->u.Manual.pbCopy[(KSIZE)paSegs[iSeg].RVA];
1951	KSIZE cNatural = paSegs[iSeg].cbMapped / sizeof(KSIZE);
1952	KSIZE idxFirstZero = cNatural;
1953	while (idxFirstZero > 0)
1954	if (pauNatural[--idxFirstZero] == 0)
1955	{ /* likely */ }
1956	else
1957	{
1958	idxFirstZero++;
1959	break;
1960	}
1961	cbTrailingZeros = (cNatural - idxFirstZero) * sizeof(KSIZE);
1962	if (cbTrailingZeros < 128)
1963	cbTrailingZeros = 0;
1964	}
1965	else
1966	cbTrailingZeros = 0;
1967
1968	/*
1969	* Add quick copy entry.
1970	*/
1971	if (cbTrailingZeros < paSegs[iSeg].cbMapped)
1972	{
1973	pMod->u.Manual.aQuickCopyChunks[iChunk].pbDst = &pMod->u.Manual.pbLoad[(KSIZE)paSegs[iSeg].RVA];
1974	pMod->u.Manual.aQuickCopyChunks[iChunk].pbSrc = &pMod->u.Manual.pbCopy[(KSIZE)paSegs[iSeg].RVA];
1975	pMod->u.Manual.aQuickCopyChunks[iChunk].cbToCopy = paSegs[iSeg].cbMapped - cbTrailingZeros;
1976	pMod->u.Manual.cQuickCopyChunks = iChunk + 1;
1977	KWLDR_LOG(("aQuickCopyChunks[%u]: %#p LB %#" KSIZE_PRI " <- %p (%.s)\n", iChunk,
1978	pMod->u.Manual.aQuickCopyChunks[iChunk].pbDst,
1979	pMod->u.Manual.aQuickCopyChunks[iChunk].cbToCopy,
1980	pMod->u.Manual.aQuickCopyChunks[iChunk].pbSrc,
1981	paSegs[iSeg].cchName, paSegs[iSeg].cchName, paSegs[iSeg].pchName));
1982	}
1983
1984	/*
1985	* Add quick zero entry.
1986	*/
1987	if (cbTrailingZeros)
1988	{
1989	KU32 iZero = pMod->u.Manual.cQuickZeroChunks;
1990	pMod->u.Manual.aQuickZeroChunks[iZero].pbDst = pMod->u.Manual.aQuickCopyChunks[iChunk].pbDst
1991	+ pMod->u.Manual.aQuickCopyChunks[iChunk].cbToCopy;
1992	pMod->u.Manual.aQuickZeroChunks[iZero].cbToZero = cbTrailingZeros;
1993	pMod->u.Manual.cQuickZeroChunks = iZero + 1;
1994	KWLDR_LOG(("aQuickZeroChunks[%u]: %#p LB %#" KSIZE_PRI " <- zero (%.s)\n", iZero,
1995	pMod->u.Manual.aQuickZeroChunks[iZero].pbDst,
1996	pMod->u.Manual.aQuickZeroChunks[iZero].cbToZero,
1997	paSegs[iSeg].cchName, paSegs[iSeg].cchName, paSegs[iSeg].pchName));
1998	}
1999	}
2000	else
2001	{
2002	/*
2003	* We're out of quick copy table entries, so just copy the whole darn thing.
2004	* We cannot 104% guarantee that the segments are in mapping order, so this is simpler.
2005	*/
2006	kHlpAssertFailed();
2007	pMod->u.Manual.aQuickCopyChunks[0].pbDst = pMod->u.Manual.pbLoad;
2008	pMod->u.Manual.aQuickCopyChunks[0].pbSrc = pMod->u.Manual.pbCopy;
2009	pMod->u.Manual.aQuickCopyChunks[0].cbToCopy = pMod->cbImage;
2010	pMod->u.Manual.cQuickCopyChunks = 1;
2011	KWLDR_LOG(("Quick copy not possible!\n"));
2012	return;
2013	}
2014	}
2015	break;
2016
2017	default:
2018	break;
2019	}
2020	}
2021
2022
2023	/**
2024	* Called from TLS allocation DLL during DLL_PROCESS_ATTACH.
2025	*
2026	* @param hDll The DLL handle.
2027	* @param idxTls The allocated TLS index.
2028	* @param ppfnTlsCallback Pointer to the TLS callback table entry.
2029	*/
2030	__declspec(dllexport) void kwLdrTlsAllocationHook(void hDll, ULONG idxTls, PIMAGE_TLS_CALLBACK ppfnTlsCallback)
2031	{
2032	/*
2033	* Do the module initialization thing first.
2034	*/
2035	PKWMODULE pMod = g_pModPendingTlsAlloc;
2036	if (pMod)
2037	{
2038	PPEB pPeb = kwSandboxGetProcessEnvironmentBlock();
2039	LIST_ENTRY *pHead;
2040	LIST_ENTRY *pCur;
2041
2042	pMod->u.Manual.idxTls = idxTls;
2043	KWLDR_LOG(("kwLdrTlsAllocationHook: idxTls=%d (%#x) for %s\n", idxTls, idxTls, pMod->pszPath));
2044
2045	/*
2046	* Try sabotage the DLL name so we can load this module again.
2047	*/
2048	pHead = &pPeb->Ldr->InMemoryOrderModuleList;
2049	for (pCur = pHead->Blink; pCur != pHead; pCur = pCur->Blink)
2050	{
2051	LDR_DATA_TABLE_ENTRY *pMte;
2052	pMte = (LDR_DATA_TABLE_ENTRY *)((KUPTR)pCur - K_OFFSETOF(LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks));
2053	if (((KUPTR)pMte->DllBase & ~(KUPTR)31) == ((KUPTR)hDll & ~(KUPTR)31))
2054	{
2055	PUNICODE_STRING pStr = &pMte->FullDllName;
2056	KSIZE off = pStr->Length / sizeof(pStr->Buffer[0]);
2057	pStr->Buffer[--off]++;
2058	pStr->Buffer[--off]++;
2059	pStr->Buffer[--off]++;
2060	KWLDR_LOG(("kwLdrTlsAllocationHook: patched the MTE (%p) for %p\n", pMte, hDll));
2061	break;
2062	}
2063	}
2064	}
2065	}
2066
2067
2068	/**
2069	* Allocates and initializes TLS variables.
2070	*
2071	* @returns 0 on success, non-zero failure.
2072	* @param pMod The module.
2073	*/
2074	static int kwLdrModuleCreateNonNativeSetupTls(PKWMODULE pMod)
2075	{
2076	KU8 pbImg = (KU8 )pMod->u.Manual.pbCopy;
2077	IMAGE_NT_HEADERS const *pNtHdrs;
2078	IMAGE_DATA_DIRECTORY const *pTlsDir;
2079
2080	if (((PIMAGE_DOS_HEADER)pbImg)->e_magic == IMAGE_DOS_SIGNATURE)
2081	pNtHdrs = (PIMAGE_NT_HEADERS)&pbImg[((PIMAGE_DOS_HEADER)pbImg)->e_lfanew];
2082	else
2083	pNtHdrs = (PIMAGE_NT_HEADERS)pbImg;
2084	kHlpAssert(pNtHdrs->Signature == IMAGE_NT_SIGNATURE);
2085
2086	pTlsDir = &pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS];
2087	if (pTlsDir->Size >= sizeof(IMAGE_TLS_DIRECTORY))
2088	{
2089	PIMAGE_TLS_DIRECTORY const paEntries = (PIMAGE_TLS_DIRECTORY)&pbImg[pTlsDir->VirtualAddress];
2090	KU32 const cEntries = pTlsDir->Size / sizeof(IMAGE_TLS_DIRECTORY);
2091	KU32 iEntry;
2092	KUPTR offIndex;
2093	KUPTR offCallbacks;
2094	KUPTR const *puCallbacks;
2095	KSIZE cbData;
2096	const wchar_t *pwszTlsDll;
2097	HMODULE hmodTlsDll;
2098
2099	/*
2100	* Check and log.
2101	*/
2102	for (iEntry = 0; iEntry < cEntries; iEntry++)
2103	{
2104	KUPTR offIndex = (KUPTR)paEntries[iEntry].AddressOfIndex - (KUPTR)pMod->u.Manual.pbLoad;
2105	KUPTR offCallbacks = (KUPTR)paEntries[iEntry].AddressOfCallBacks - (KUPTR)pMod->u.Manual.pbLoad;
2106	KUPTR const puCallbacks = (KUPTR const )&pbImg[offCallbacks];
2107	KWLDR_LOG(("TLS DIR #%u: %#x-%#x idx=@%#x (%#x) callbacks=@%#x (%#x) cbZero=%#x flags=%#x\n",
2108	iEntry, paEntries[iEntry].StartAddressOfRawData, paEntries[iEntry].EndAddressOfRawData,
2109	paEntries[iEntry].AddressOfIndex, offIndex, paEntries[iEntry].AddressOfCallBacks, offCallbacks,
2110	paEntries[iEntry].SizeOfZeroFill, paEntries[iEntry].Characteristics));
2111
2112	if (offIndex >= pMod->cbImage)
2113	{
2114	kwErrPrintf("TLS entry #%u in %s has an invalid index address: %p, RVA %p, image size %#x\n",
2115	iEntry, pMod->pszPath, paEntries[iEntry].AddressOfIndex, offIndex, pMod->cbImage);
2116	return -1;
2117	}
2118	if (offCallbacks >= pMod->cbImage)
2119	{
2120	kwErrPrintf("TLS entry #%u in %s has an invalid callbacks address: %p, RVA %p, image size %#x\n",
2121	iEntry, pMod->pszPath, paEntries[iEntry].AddressOfCallBacks, offCallbacks, pMod->cbImage);
2122	return -1;
2123	}
2124	while (*puCallbacks != 0)
2125	{
2126	KWLDR_LOG(("TLS DIR #%u: callback %p, RVA %#x\n",
2127	iEntry, puCallbacks, puCallbacks - (KUPTR)pMod->u.Manual.pbLoad));
2128	puCallbacks++;
2129	}
2130	if (paEntries[iEntry].Characteristics > IMAGE_SCN_ALIGN_16BYTES)
2131	{
2132	kwErrPrintf("TLS entry #%u in %s has an unsupported alignment restriction: %#x\n",
2133	iEntry, pMod->pszPath, paEntries[iEntry].Characteristics);
2134	return -1;
2135	}
2136	}
2137
2138	if (cEntries > 1)
2139	{
2140	kwErrPrintf("More than one TLS directory entry in %s: %u\n", pMod->pszPath, cEntries);
2141	return -1;
2142	}
2143
2144	/*
2145	* Make the allocation by loading a new instance of one of the TLS dlls.
2146	* The DLL will make a call to
2147	*/
2148	offIndex = (KUPTR)paEntries[0].AddressOfIndex - (KUPTR)pMod->u.Manual.pbLoad;
2149	offCallbacks = (KUPTR)paEntries[0].AddressOfCallBacks - (KUPTR)pMod->u.Manual.pbLoad;
2150	puCallbacks = (KUPTR const *)&pbImg[offCallbacks];
2151	cbData = paEntries[0].SizeOfZeroFill + (paEntries[0].EndAddressOfRawData - paEntries[0].StartAddressOfRawData);
2152	if (cbData <= 1024)
2153	pwszTlsDll = L"kWorkerTls1K.dll";
2154	else if (cbData <= 65536)
2155	pwszTlsDll = L"kWorkerTls64K.dll";
2156	else if (cbData <= 524288)
2157	pwszTlsDll = L"kWorkerTls512K.dll";
2158	else
2159	{
2160	kwErrPrintf("TLS data size in %s is too big: %u (%#p), max 512KB\n", pMod->pszPath, (unsigned)cbData, cbData);
2161	return -1;
2162	}
2163
2164	pMod->u.Manual.idxTls = KU32_MAX;
2165	pMod->u.Manual.offTlsInitData = (KU32)((KUPTR)paEntries[0].StartAddressOfRawData - (KUPTR)pMod->u.Manual.pbLoad);
2166	pMod->u.Manual.cbTlsInitData = (KU32)(paEntries[0].EndAddressOfRawData - paEntries[0].StartAddressOfRawData);
2167	pMod->u.Manual.cbTlsAlloc = (KU32)cbData;
2168	pMod->u.Manual.cTlsCallbacks = 0;
2169	while (puCallbacks[pMod->u.Manual.cTlsCallbacks] != 0)
2170	pMod->u.Manual.cTlsCallbacks++;
2171	pMod->u.Manual.offTlsCallbacks = pMod->u.Manual.cTlsCallbacks ? (KU32)offCallbacks : KU32_MAX;
2172
2173	g_pModPendingTlsAlloc = pMod;
2174	hmodTlsDll = LoadLibraryExW(pwszTlsDll, NULL /hFile/, 0);
2175	g_pModPendingTlsAlloc = NULL;
2176	if (hmodTlsDll == NULL)
2177	{
2178	kwErrPrintf("TLS allocation failed for '%s': LoadLibraryExW(%ls) -> %u\n", pMod->pszPath, pwszTlsDll, GetLastError());
2179	return -1;
2180	}
2181	if (pMod->u.Manual.idxTls == KU32_MAX)
2182	{
2183	kwErrPrintf("TLS allocation failed for '%s': idxTls = KU32_MAX\n", pMod->pszPath, GetLastError());
2184	return -1;
2185	}
2186
2187	(KU32 )&pMod->u.Manual.pbCopy[offIndex] = pMod->u.Manual.idxTls;
2188	KWLDR_LOG(("kwLdrModuleCreateNonNativeSetupTls: idxTls=%d hmodTlsDll=%p (%ls) cbData=%#x\n",
2189	pMod->u.Manual.idxTls, hmodTlsDll, pwszTlsDll, cbData));
2190	}
2191	return 0;
2192	}
2193
2194
2195	/**
2196	* Creates a module using the our own loader.
2197	*
2198	* @returns Module w/ 1 reference on success, NULL on failure.
2199	* @param pszPath The normalized path to the module.
2200	* @param uHashPath The module path hash.
2201	* @param fExe K_TRUE if this is an executable image, K_FALSE
2202	* if not. Executable images does not get entered
2203	* into the global module table.
2204	* @param pExeMod The executable module of the process (for
2205	* resolving imports). NULL if fExe is set.
2206	* @param pszSearchPath The PATH to search for imports. Can be NULL.
2207	*/
2208	static PKWMODULE kwLdrModuleCreateNonNative(const char *pszPath, KU32 uHashPath, KBOOL fExe,
2209	PKWMODULE pExeMod, const char *pszSearchPath)
2210	{
2211	/*
2212	* Open the module and check the type.
2213	*/
2214	PKLDRMOD pLdrMod;
2215	int rc = kLdrModOpen(pszPath, 0 /fFlags/, (KCPUARCH)K_ARCH, &pLdrMod);
2216	if (rc == 0)
2217	{
2218	switch (pLdrMod->enmType)
2219	{
2220	case KLDRTYPE_EXECUTABLE_FIXED:
2221	case KLDRTYPE_EXECUTABLE_RELOCATABLE:
2222	case KLDRTYPE_EXECUTABLE_PIC:
2223	if (!fExe)
2224	rc = KERR_GENERAL_FAILURE;
2225	break;
2226
2227	case KLDRTYPE_SHARED_LIBRARY_RELOCATABLE:
2228	case KLDRTYPE_SHARED_LIBRARY_PIC:
2229	case KLDRTYPE_SHARED_LIBRARY_FIXED:
2230	if (fExe)
2231	rc = KERR_GENERAL_FAILURE;
2232	break;
2233
2234	default:
2235	rc = KERR_GENERAL_FAILURE;
2236	break;
2237	}
2238	if (rc == 0)
2239	{
2240	KI32 cImports = kLdrModNumberOfImports(pLdrMod, NULL /pvBits/);
2241	if (cImports >= 0)
2242	{
2243	/*
2244	* Create the entry.
2245	*/
2246	KSIZE cbPath = kHlpStrLen(pszPath) + 1;
2247	PKWMODULE pMod = (PKWMODULE)kHlpAllocZ(sizeof(*pMod)
2248	+ sizeof(pMod) * cImports
2249	+ cbPath
2250	+ cbPath * 2 * sizeof(wchar_t));
2251	if (pMod)
2252	{
2253	KBOOL fFixed;
2254
2255	pMod->cRefs = 1;
2256	pMod->offFilename = (KU16)(kHlpGetFilename(pszPath) - pszPath);
2257	pMod->uHashPath = uHashPath;
2258	pMod->fExe = fExe;
2259	pMod->fNative = K_FALSE;
2260	pMod->pLdrMod = pLdrMod;
2261	pMod->u.Manual.cImpMods = (KU32)cImports;
2262	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
2263	pMod->u.Manual.fRegisteredFunctionTable = K_FALSE;
2264	#endif
2265	pMod->u.Manual.fUseLdBuf = K_FALSE;
2266	pMod->u.Manual.fCanDoQuick = K_FALSE;
2267	pMod->u.Manual.cQuickZeroChunks = 0;
2268	pMod->u.Manual.cQuickCopyChunks = 0;
2269	pMod->u.Manual.idxTls = KU32_MAX;
2270	pMod->u.Manual.offTlsInitData = KU32_MAX;
2271	pMod->u.Manual.cbTlsInitData = 0;
2272	pMod->u.Manual.cbTlsAlloc = 0;
2273	pMod->u.Manual.cTlsCallbacks = 0;
2274	pMod->u.Manual.offTlsCallbacks = 0;
2275	pMod->pszPath = (char *)kHlpMemCopy(&pMod->u.Manual.apImpMods[cImports + 1], pszPath, cbPath);
2276	pMod->pwszPath = (wchar_t *)(pMod->pszPath + cbPath + (cbPath & 1));
2277	kwStrToUtf16(pMod->pszPath, (wchar_t )pMod->pwszPath, cbPath 2);
2278
2279	/*
2280	* Figure out where to load it and get memory there.
2281	*/
2282	fFixed = pLdrMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
2283	\|\| pLdrMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
2284	pMod->u.Manual.pbLoad = fFixed ? (KU8 *)(KUPTR)pLdrMod->aSegments[0].LinkAddress : NULL;
2285	pMod->cbImage = (KSIZE)kLdrModSize(pLdrMod);
2286	if ( !fFixed
2287	\|\| pLdrMod->enmType != KLDRTYPE_EXECUTABLE_FIXED /* only allow fixed executables */
2288	\|\| (KUPTR)pMod->u.Manual.pbLoad - (KUPTR)g_abDefLdBuf >= sizeof(g_abDefLdBuf)
2289	\|\| sizeof(g_abDefLdBuf) - (KUPTR)pMod->u.Manual.pbLoad - (KUPTR)g_abDefLdBuf < pMod->cbImage)
2290	rc = kHlpPageAlloc((void **)&pMod->u.Manual.pbLoad, pMod->cbImage, KPROT_EXECUTE_READWRITE, fFixed);
2291	else
2292	pMod->u.Manual.fUseLdBuf = K_TRUE;
2293	if (rc == 0)
2294	{
2295	rc = kHlpPageAlloc(&pMod->u.Manual.pbCopy, pMod->cbImage, KPROT_READWRITE, K_FALSE);
2296	if (rc == 0)
2297	{
2298	KI32 iImp;
2299
2300	/*
2301	* Link the module (unless it's an executable image) and process the imports.
2302	*/
2303	pMod->hOurMod = (HMODULE)pMod->u.Manual.pbLoad;
2304	if (!fExe)
2305	kwLdrModuleLink(pMod);
2306	KW_LOG(("New module: %p LB %#010x %s (kLdr)\n",
2307	pMod->u.Manual.pbLoad, pMod->cbImage, pMod->pszPath));
2308	KW_LOG(("TODO: .reload /f %s=%p\n", pMod->pszPath, pMod->u.Manual.pbLoad));
2309	kwDebuggerPrintf("TODO: .reload /f %s=%p\n", pMod->pszPath, pMod->u.Manual.pbLoad);
2310
2311	for (iImp = 0; iImp < cImports; iImp++)
2312	{
2313	char szName[1024];
2314	rc = kLdrModGetImport(pMod->pLdrMod, NULL /pvBits/, iImp, szName, sizeof(szName));
2315	if (rc == 0)
2316	{
2317	rc = kwLdrModuleResolveAndLookup(szName, pExeMod, pMod, pszSearchPath,
2318	&pMod->u.Manual.apImpMods[iImp]);
2319	if (rc == 0)
2320	continue;
2321	}
2322	break;
2323	}
2324
2325	if (rc == 0)
2326	{
2327	rc = kLdrModGetBits(pLdrMod, pMod->u.Manual.pbCopy, (KUPTR)pMod->u.Manual.pbLoad,
2328	kwLdrModuleGetImportCallback, pMod);
2329	if (rc == 0)
2330	{
2331	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
2332	/*
2333	* Find the function table. No validation here because the
2334	* loader did that already, right...
2335	*/
2336	KU8 pbImg = (KU8 )pMod->u.Manual.pbCopy;
2337	IMAGE_NT_HEADERS const *pNtHdrs;
2338	IMAGE_DATA_DIRECTORY const *pXcptDir;
2339	if (((PIMAGE_DOS_HEADER)pbImg)->e_magic == IMAGE_DOS_SIGNATURE)
2340	pNtHdrs = (PIMAGE_NT_HEADERS)&pbImg[((PIMAGE_DOS_HEADER)pbImg)->e_lfanew];
2341	else
2342	pNtHdrs = (PIMAGE_NT_HEADERS)pbImg;
2343	pXcptDir = &pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION];
2344	kHlpAssert(pNtHdrs->Signature == IMAGE_NT_SIGNATURE);
2345	if (pXcptDir->Size > 0)
2346	{
2347	pMod->u.Manual.cFunctions = pXcptDir->Size / sizeof(pMod->u.Manual.paFunctions[0]);
2348	kHlpAssert( pMod->u.Manual.cFunctions * sizeof(pMod->u.Manual.paFunctions[0])
2349	== pXcptDir->Size);
2350	pMod->u.Manual.paFunctions = (PRUNTIME_FUNCTION)&pbImg[pXcptDir->VirtualAddress];
2351	}
2352	else
2353	{
2354	pMod->u.Manual.cFunctions = 0;
2355	pMod->u.Manual.paFunctions = NULL;
2356	}
2357	#endif
2358
2359	kwLdrModuleCreateNonNativeSetupQuickZeroAndCopy(pMod);
2360
2361	rc = kwLdrModuleCreateNonNativeSetupTls(pMod);
2362	if (rc == 0)
2363	{
2364	/*
2365	* Final finish.
2366	*/
2367	pMod->u.Manual.pvBits = pMod->u.Manual.pbCopy;
2368	pMod->u.Manual.enmState = KWMODSTATE_NEEDS_BITS;
2369	g_cModules++;
2370	g_cNonNativeModules++;
2371	return pMod;
2372	}
2373	}
2374	else
2375	kwErrPrintf("kLdrModGetBits failed for %s: %#x (%d)\n", pszPath, rc, rc);
2376	}
2377
2378	kwLdrModuleRelease(pMod);
2379	return NULL;
2380	}
2381
2382	kHlpPageFree(pMod->u.Manual.pbLoad, pMod->cbImage);
2383	kwErrPrintf("Failed to allocate %#x bytes\n", pMod->cbImage);
2384	}
2385	else if (fFixed)
2386	kwErrPrintf("Failed to allocate %#x bytes at %p\n",
2387	pMod->cbImage, (void *)(KUPTR)pLdrMod->aSegments[0].LinkAddress);
2388	else
2389	kwErrPrintf("Failed to allocate %#x bytes\n", pMod->cbImage);
2390	}
2391	}
2392	}
2393	kLdrModClose(pLdrMod);
2394	}
2395	else
2396	kwErrPrintf("kLdrOpen failed with %#x (%d) for %s\n", rc, rc, pszPath);
2397	return NULL;
2398	}
2399
2400
2401	/** Implements FNKLDRMODGETIMPORT, used by kwLdrModuleCreate. */
2402	static int kwLdrModuleGetImportCallback(PKLDRMOD pMod, KU32 iImport, KU32 iSymbol, const char *pchSymbol, KSIZE cchSymbol,
2403	const char pszVersion, PKLDRADDR puValue, KU32 pfKind, void *pvUser)
2404	{
2405	PKWMODULE pCurMod = (PKWMODULE)pvUser;
2406	PKWMODULE pImpMod = pCurMod->u.Manual.apImpMods[iImport];
2407	int rc;
2408	K_NOREF(pMod);
2409
2410	if (pImpMod->fNative)
2411	rc = kLdrModQuerySymbol(pImpMod->pLdrMod, NULL /pvBits/, KLDRMOD_BASEADDRESS_MAP,
2412	iSymbol, pchSymbol, cchSymbol, pszVersion,
2413	NULL /pfnGetForwarder/, NULL /pvUSer/,
2414	puValue, pfKind);
2415	else
2416	rc = kLdrModQuerySymbol(pImpMod->pLdrMod, pImpMod->u.Manual.pvBits, (KUPTR)pImpMod->u.Manual.pbLoad,
2417	iSymbol, pchSymbol, cchSymbol, pszVersion,
2418	NULL /pfnGetForwarder/, NULL /pvUSer/,
2419	puValue, pfKind);
2420	if (rc == 0)
2421	{
2422	KU32 i = g_cSandboxReplacements;
2423	while (i-- > 0)
2424	if ( g_aSandboxReplacements[i].cchFunction == cchSymbol
2425	&& kHlpMemComp(g_aSandboxReplacements[i].pszFunction, pchSymbol, cchSymbol) == 0)
2426	{
2427	if ( !g_aSandboxReplacements[i].pszModule
2428	\|\| kHlpStrICompAscii(g_aSandboxReplacements[i].pszModule, &pImpMod->pszPath[pImpMod->offFilename]) == 0)
2429	{
2430	if ( pCurMod->fExe
2431	\|\| !g_aSandboxReplacements[i].fOnlyExe)
2432	{
2433	KW_LOG(("replacing %s!%s\n",&pImpMod->pszPath[pImpMod->offFilename], g_aSandboxReplacements[i].pszFunction));
2434	*puValue = g_aSandboxReplacements[i].pfnReplacement;
2435	}
2436	break;
2437	}
2438	}
2439	}
2440
2441	//printf("iImport=%u (%s) %.s rc=%d\n", iImport, &pImpMod->pszPath[pImpMod->offFilename], cchSymbol, cchSymbol, pchSymbol, rc);
2442	KW_LOG(("iImport=%u (%s) %.s rc=%d\n", iImport, &pImpMod->pszPath[pImpMod->offFilename], cchSymbol, cchSymbol, pchSymbol, rc));
2443	return rc;
2444
2445	}
2446
2447
2448	/**
2449	* Gets the main entrypoint for a module.
2450	*
2451	* @returns 0 on success, KERR on failure
2452	* @param pMod The module.
2453	* @param puAddrMain Where to return the address.
2454	*/
2455	static int kwLdrModuleQueryMainEntrypoint(PKWMODULE pMod, KUPTR *puAddrMain)
2456	{
2457	KLDRADDR uLdrAddrMain;
2458	int rc = kLdrModQueryMainEntrypoint(pMod->pLdrMod, pMod->u.Manual.pvBits, (KUPTR)pMod->u.Manual.pbLoad, &uLdrAddrMain);
2459	if (rc == 0)
2460	{
2461	*puAddrMain = (KUPTR)uLdrAddrMain;
2462	return 0;
2463	}
2464	return rc;
2465	}
2466
2467
2468	/**
2469	* Whether to apply g_aSandboxNativeReplacements to the imports of this module.
2470	*
2471	* @returns K_TRUE/K_FALSE.
2472	* @param pszFilename The filename (no path).
2473	* @param enmLocation The location.
2474	*/
2475	static KBOOL kwLdrModuleShouldDoNativeReplacements(const char *pszFilename, KWLOCATION enmLocation)
2476	{
2477	if (enmLocation != KWLOCATION_SYSTEM32)
2478	return K_TRUE;
2479	return kHlpStrNICompAscii(pszFilename, TUPLE("msvc")) == 0
2480	\|\| kHlpStrNICompAscii(pszFilename, TUPLE("msdis")) == 0
2481	\|\| kHlpStrNICompAscii(pszFilename, TUPLE("mspdb")) == 0;
2482	}
2483
2484
2485	/**
2486	* Lazily initializes the g_pWinSys32 variable.
2487	*/
2488	static PKFSDIR kwLdrResolveWinSys32(void)
2489	{
2490	KFSLOOKUPERROR enmError;
2491	PKFSDIR pWinSys32;
2492
2493	/* Get the path first. */
2494	char szSystem32[MAX_PATH];
2495	if (GetSystemDirectoryA(szSystem32, sizeof(szSystem32)) >= sizeof(szSystem32))
2496	{
2497	kwErrPrintf("GetSystemDirectory failed: %u\n", GetLastError());
2498	strcpy(szSystem32, "C:\\Windows\\System32");
2499	}
2500
2501	/* Look it up and verify it. */
2502	pWinSys32 = (PKFSDIR)kFsCacheLookupA(g_pFsCache, szSystem32, &enmError);
2503	if (pWinSys32)
2504	{
2505	if (pWinSys32->Obj.bObjType == KFSOBJ_TYPE_DIR)
2506	{
2507	g_pWinSys32 = pWinSys32;
2508	return pWinSys32;
2509	}
2510
2511	kwErrPrintf("System directory '%s' isn't of 'DIR' type: %u\n", szSystem32, g_pWinSys32->Obj.bObjType);
2512	}
2513	else
2514	kwErrPrintf("Failed to lookup system directory '%s': %u\n", szSystem32, enmError);
2515	return NULL;
2516	}
2517
2518
2519	/**
2520	* Whether we can load this DLL natively or not.
2521	*
2522	* @returns K_TRUE/K_FALSE.
2523	* @param pszFilename The filename (no path).
2524	* @param enmLocation The location.
2525	* @param pszFullPath The full filename and path.
2526	*/
2527	static KBOOL kwLdrModuleCanLoadNatively(const char pszFilename, KWLOCATION enmLocation, const char pszFullPath)
2528	{
2529	if (enmLocation == KWLOCATION_SYSTEM32)
2530	return K_TRUE;
2531	if (enmLocation == KWLOCATION_UNKNOWN_NATIVE)
2532	return K_TRUE;
2533
2534	/* If the location is unknown, we must check if it's some dynamic loading
2535	of a SYSTEM32 DLL with a full path. We do not want to load these ourselves! */
2536	if (enmLocation == KWLOCATION_UNKNOWN)
2537	{
2538	PKFSDIR pWinSys32 = g_pWinSys32;
2539	if (!pWinSys32)
2540	pWinSys32 = kwLdrResolveWinSys32();
2541	if (pWinSys32)
2542	{
2543	KFSLOOKUPERROR enmError;
2544	PKFSOBJ pFsObj = kFsCacheLookupA(g_pFsCache, pszFullPath, &enmError);
2545	if (pFsObj)
2546	{
2547	KBOOL fInWinSys32 = pFsObj->pParent == pWinSys32;
2548	kFsCacheObjRelease(g_pFsCache, pFsObj);
2549	if (fInWinSys32)
2550	return K_TRUE;
2551	}
2552	}
2553	}
2554
2555	return kHlpStrNICompAscii(pszFilename, TUPLE("msvc")) == 0
2556	\|\| kHlpStrNICompAscii(pszFilename, TUPLE("msdis")) == 0
2557	\|\| kHlpStrNICompAscii(pszFilename, TUPLE("mspdb")) == 0;
2558	}
2559
2560
2561	/**
2562	* Check if the path leads to a regular file (that exists).
2563	*
2564	* @returns K_TRUE / K_FALSE
2565	* @param pszPath Path to the file to check out.
2566	*/
2567	static KBOOL kwLdrModuleIsRegularFile(const char *pszPath)
2568	{
2569	/* For stuff with .DLL extensions, we can use the GetFileAttribute cache to speed this up! */
2570	KSIZE cchPath = kHlpStrLen(pszPath);
2571	if ( cchPath > 3
2572	&& pszPath[cchPath - 4] == '.'
2573	&& (pszPath[cchPath - 3] == 'd' \|\| pszPath[cchPath - 3] == 'D')
2574	&& (pszPath[cchPath - 2] == 'l' \|\| pszPath[cchPath - 2] == 'L')
2575	&& (pszPath[cchPath - 1] == 'l' \|\| pszPath[cchPath - 1] == 'L') )
2576	{
2577	KFSLOOKUPERROR enmError;
2578	PKFSOBJ pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszPath, &enmError);
2579	if (pFsObj)
2580	{
2581	KBOOL fRc = pFsObj->bObjType == KFSOBJ_TYPE_FILE;
2582	kFsCacheObjRelease(g_pFsCache, pFsObj);
2583	return fRc;
2584	}
2585	}
2586	else
2587	{
2588	BirdStat_T Stat;
2589	int rc = birdStatFollowLink(pszPath, &Stat);
2590	if (rc == 0)
2591	{
2592	if (S_ISREG(Stat.st_mode))
2593	return K_TRUE;
2594	}
2595	}
2596	return K_FALSE;
2597	}
2598
2599
2600	/**
2601	* Worker for kwLdrModuleResolveAndLookup that checks out one possibility.
2602	*
2603	* If the file exists, we consult the module hash table before trying to load it
2604	* off the disk.
2605	*
2606	* @returns Pointer to module on success, NULL if not found, ~(KUPTR)0 on
2607	* failure.
2608	* @param pszPath The name of the import module.
2609	* @param enmLocation The location we're searching. This is used in
2610	* the heuristics for determining if we can use the
2611	* native loader or need to sandbox the DLL.
2612	* @param pExe The executable (optional).
2613	* @param pszSearchPath The PATH to search (optional).
2614	*/
2615	static PKWMODULE kwLdrModuleTryLoadDll(const char pszPath, KWLOCATION enmLocation, PKWMODULE pExeMod, const char pszSearchPath)
2616	{
2617	/*
2618	* Does the file exists and is it a regular file?
2619	*/
2620	if (kwLdrModuleIsRegularFile(pszPath))
2621	{
2622	/*
2623	* Yes! Normalize it and look it up in the hash table.
2624	*/
2625	char szNormPath[1024];
2626	int rc = kwPathNormalize(pszPath, szNormPath, sizeof(szNormPath));
2627	if (rc == 0)
2628	{
2629	const char *pszName;
2630	KU32 const uHashPath = kwStrHash(szNormPath);
2631	unsigned idxHash = uHashPath % K_ELEMENTS(g_apModules);
2632	PKWMODULE pMod = g_apModules[idxHash];
2633	if (pMod)
2634	{
2635	do
2636	{
2637	if ( pMod->uHashPath == uHashPath
2638	&& kHlpStrComp(pMod->pszPath, szNormPath) == 0)
2639	return kwLdrModuleRetain(pMod);
2640	pMod = pMod->pNext;
2641	} while (pMod);
2642	}
2643
2644	/*
2645	* Not in the hash table, so we have to load it from scratch.
2646	*/
2647	pszName = kHlpGetFilename(szNormPath);
2648	if (kwLdrModuleCanLoadNatively(pszName, enmLocation, szNormPath))
2649	pMod = kwLdrModuleCreateNative(szNormPath, uHashPath,
2650	kwLdrModuleShouldDoNativeReplacements(pszName, enmLocation));
2651	else
2652	pMod = kwLdrModuleCreateNonNative(szNormPath, uHashPath, K_FALSE /fExe/, pExeMod, pszSearchPath);
2653	if (pMod)
2654	return pMod;
2655	return (PKWMODULE)~(KUPTR)0;
2656	}
2657	}
2658	return NULL;
2659	}
2660
2661
2662	/**
2663	* Gets a reference to the module by the given name.
2664	*
2665	* We must do the search path thing, as our hash table may multiple DLLs with
2666	* the same base name due to different tools version and similar. We'll use a
2667	* modified search sequence, though. No point in searching the current
2668	* directory for instance.
2669	*
2670	* @returns 0 on success, KERR on failure.
2671	* @param pszName The name of the import module.
2672	* @param pExe The executable (optional).
2673	* @param pImporter The module doing the importing (optional).
2674	* @param pszSearchPath The PATH to search (optional).
2675	* @param ppMod Where to return the module pointer w/ reference.
2676	*/
2677	static int kwLdrModuleResolveAndLookup(const char *pszName, PKWMODULE pExe, PKWMODULE pImporter,
2678	const char pszSearchPath, PKWMODULE ppMod)
2679	{
2680	KSIZE const cchName = kHlpStrLen(pszName);
2681	char szPath[1024];
2682	char *psz;
2683	PKWMODULE pMod = NULL;
2684	KBOOL fNeedSuffix = *kHlpGetExt(pszName) == '\0' && kHlpGetFilename(pszName) == pszName;
2685	KSIZE cchSuffix = fNeedSuffix ? 4 : 0;
2686
2687
2688	/* The import path. */
2689	if (pMod == NULL && pImporter != NULL)
2690	{
2691	if (pImporter->offFilename + cchName + cchSuffix >= sizeof(szPath))
2692	return KERR_BUFFER_OVERFLOW;
2693
2694	psz = (char *)kHlpMemPCopy(kHlpMemPCopy(szPath, pImporter->pszPath, pImporter->offFilename), pszName, cchName + 1);
2695	if (fNeedSuffix)
2696	kHlpMemCopy(psz - 1, ".dll", sizeof(".dll"));
2697	pMod = kwLdrModuleTryLoadDll(szPath, KWLOCATION_IMPORTER_DIR, pExe, pszSearchPath);
2698	}
2699
2700	/* Application directory first. */
2701	if (pMod == NULL && pExe != NULL && pExe != pImporter)
2702	{
2703	if (pExe->offFilename + cchName + cchSuffix >= sizeof(szPath))
2704	return KERR_BUFFER_OVERFLOW;
2705	psz = (char *)kHlpMemPCopy(kHlpMemPCopy(szPath, pExe->pszPath, pExe->offFilename), pszName, cchName + 1);
2706	if (fNeedSuffix)
2707	kHlpMemCopy(psz - 1, ".dll", sizeof(".dll"));
2708	pMod = kwLdrModuleTryLoadDll(szPath, KWLOCATION_EXE_DIR, pExe, pszSearchPath);
2709	}
2710
2711	/* The windows directory. */
2712	if (pMod == NULL)
2713	{
2714	UINT cchDir = GetSystemDirectoryA(szPath, sizeof(szPath));
2715	if ( cchDir <= 2
2716	\|\| cchDir + 1 + cchName + cchSuffix >= sizeof(szPath))
2717	return KERR_BUFFER_OVERFLOW;
2718	szPath[cchDir++] = '\\';
2719	psz = (char *)kHlpMemPCopy(&szPath[cchDir], pszName, cchName + 1);
2720	if (fNeedSuffix)
2721	kHlpMemCopy(psz - 1, ".dll", sizeof(".dll"));
2722	pMod = kwLdrModuleTryLoadDll(szPath, KWLOCATION_SYSTEM32, pExe, pszSearchPath);
2723	}
2724
2725	/* The path. */
2726	if ( pMod == NULL
2727	&& pszSearchPath)
2728	{
2729	const char *pszCur = pszSearchPath;
2730	while (*pszCur != '\0')
2731	{
2732	/* Find the end of the component */
2733	KSIZE cch = 0;
2734	while (pszCur[cch] != ';' && pszCur[cch] != '\0')
2735	cch++;
2736
2737	if ( cch > 0 /* wrong, but whatever */
2738	&& cch + 1 + cchName + cchSuffix < sizeof(szPath))
2739	{
2740	char *pszDst = kHlpMemPCopy(szPath, pszCur, cch);
2741	if ( szPath[cch - 1] != ':'
2742	&& szPath[cch - 1] != '/'
2743	&& szPath[cch - 1] != '\\')
2744	*pszDst++ = '\\';
2745	pszDst = kHlpMemPCopy(pszDst, pszName, cchName);
2746	if (fNeedSuffix)
2747	pszDst = kHlpMemPCopy(pszDst, ".dll", 4);
2748	*pszDst = '\0';
2749
2750	pMod = kwLdrModuleTryLoadDll(szPath, KWLOCATION_SYSTEM32, pExe, pszSearchPath);
2751	if (pMod)
2752	break;
2753	}
2754
2755	/* Advance */
2756	pszCur += cch;
2757	while (*pszCur == ';')
2758	pszCur++;
2759	}
2760	}
2761
2762	/* Return. */
2763	if (pMod != NULL && pMod != (PKWMODULE)~(KUPTR)0)
2764	{
2765	*ppMod = pMod;
2766	return 0;
2767	}
2768	*ppMod = NULL;
2769	return KERR_GENERAL_FAILURE;
2770	}
2771
2772
2773	/**
2774	* Does the TLS memory initialization for a module on the current thread.
2775	*
2776	* @returns 0 on success, error on failure.
2777	* @param pMod The module.
2778	*/
2779	static int kwLdrCallTlsAllocateAndInit(PKWMODULE pMod)
2780	{
2781	if (pMod->u.Manual.idxTls != KU32_MAX)
2782	{
2783	PTEB pTeb = NtCurrentTeb();
2784	void *ppvTls = (void **)( (KUPTR)pTeb + (sizeof(void ) == 4 ? 0x2c : 0x58) );
2785	KU8 pbData = (KU8 )ppvTls[pMod->u.Manual.idxTls];
2786	KWLDR_LOG(("%s: TLS: Initializing %#x (%#x), idxTls=%d\n",
2787	pMod->pszPath, pbData, pMod->u.Manual.cbTlsAlloc, pMod->u.Manual.cbTlsInitData, pMod->u.Manual.idxTls));
2788	if (pMod->u.Manual.cbTlsInitData < pMod->u.Manual.cbTlsAlloc)
2789	kHlpMemSet(&pbData[pMod->u.Manual.cbTlsInitData], 0, pMod->u.Manual.cbTlsAlloc);
2790	if (pMod->u.Manual.cbTlsInitData)
2791	kHlpMemCopy(pbData, &pMod->u.Manual.pbCopy[pMod->u.Manual.offTlsInitData], pMod->u.Manual.cbTlsInitData);
2792	}
2793	return 0;
2794	}
2795
2796
2797	/**
2798	* Does the TLS callbacks for a module.
2799	*
2800	* @param pMod The module.
2801	* @param dwReason The callback reason.
2802	*/
2803	static void kwLdrCallTlsCallbacks(PKWMODULE pMod, DWORD dwReason)
2804	{
2805	if (pMod->u.Manual.cTlsCallbacks)
2806	{
2807	PIMAGE_TLS_CALLBACK pCallback = (PIMAGE_TLS_CALLBACK )&pMod->u.Manual.pbLoad[pMod->u.Manual.offTlsCallbacks];
2808	do
2809	{
2810	KWLDR_LOG(("%s: Calling TLS callback %p(%p,%#x,0)\n", pMod->pszPath, *pCallback, pMod->hOurMod, dwReason));
2811	(*pCallback)(pMod->hOurMod, dwReason, 0);
2812	} while (*++pCallback);
2813	}
2814	}
2815
2816
2817	/**
2818	* Does module initialization starting at @a pMod.
2819	*
2820	* This is initially used on the executable. Later it is used by the
2821	* LoadLibrary interceptor.
2822	*
2823	* @returns 0 on success, error on failure.
2824	* @param pMod The module to initialize.
2825	*/
2826	static int kwLdrModuleInitTree(PKWMODULE pMod)
2827	{
2828	int rc = 0;
2829	if (!pMod->fNative)
2830	{
2831	KWLDR_LOG(("kwLdrModuleInitTree: enmState=%#x idxTls=%u %s\n",
2832	pMod->u.Manual.enmState, pMod->u.Manual.idxTls, pMod->pszPath));
2833
2834	/*
2835	* Need to copy bits?
2836	*/
2837	if (pMod->u.Manual.enmState == KWMODSTATE_NEEDS_BITS)
2838	{
2839	if (pMod->u.Manual.fUseLdBuf)
2840	{
2841	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
2842	if (g_pModInLdBuf != NULL && g_pModInLdBuf != pMod && pMod->u.Manual.fRegisteredFunctionTable)
2843	{
2844	BOOLEAN fRc = RtlDeleteFunctionTable(pMod->u.Manual.paFunctions);
2845	kHlpAssert(fRc); K_NOREF(fRc);
2846	}
2847	#endif
2848	g_pModPrevInLdBuf = g_pModInLdBuf;
2849	g_pModInLdBuf = pMod;
2850	}
2851
2852	/* Do quick zeroing and copying when we can. */
2853	pMod->u.Manual.fCanDoQuick = K_FALSE;
2854	if ( pMod->u.Manual.fCanDoQuick
2855	&& ( !pMod->u.Manual.fUseLdBuf
2856	\|\| g_pModPrevInLdBuf == pMod))
2857	{
2858	/* Zero first. */
2859	kHlpAssert(pMod->u.Manual.cQuickZeroChunks <= 3);
2860	switch (pMod->u.Manual.cQuickZeroChunks)
2861	{
2862	case 3: kHlpMemSet(pMod->u.Manual.aQuickZeroChunks[2].pbDst, 0, pMod->u.Manual.aQuickZeroChunks[2].cbToZero);
2863	case 2: kHlpMemSet(pMod->u.Manual.aQuickZeroChunks[1].pbDst, 0, pMod->u.Manual.aQuickZeroChunks[1].cbToZero);
2864	case 1: kHlpMemSet(pMod->u.Manual.aQuickZeroChunks[0].pbDst, 0, pMod->u.Manual.aQuickZeroChunks[0].cbToZero);
2865	case 0: break;
2866	}
2867
2868	/* Then copy. */
2869	kHlpAssert(pMod->u.Manual.cQuickCopyChunks > 0);
2870	kHlpAssert(pMod->u.Manual.cQuickCopyChunks <= 3);
2871	switch (pMod->u.Manual.cQuickCopyChunks)
2872	{
2873	case 3: kHlpMemCopy(pMod->u.Manual.aQuickCopyChunks[2].pbDst, pMod->u.Manual.aQuickCopyChunks[2].pbSrc,
2874	pMod->u.Manual.aQuickCopyChunks[2].cbToCopy);
2875	case 2: kHlpMemCopy(pMod->u.Manual.aQuickCopyChunks[1].pbDst, pMod->u.Manual.aQuickCopyChunks[1].pbSrc,
2876	pMod->u.Manual.aQuickCopyChunks[1].cbToCopy);
2877	case 1: kHlpMemCopy(pMod->u.Manual.aQuickCopyChunks[0].pbDst, pMod->u.Manual.aQuickCopyChunks[0].pbSrc,
2878	pMod->u.Manual.aQuickCopyChunks[0].cbToCopy);
2879	case 0: break;
2880	}
2881	}
2882	/* Must copy the whole image. */
2883	else
2884	{
2885	kHlpMemCopy(pMod->u.Manual.pbLoad, pMod->u.Manual.pbCopy, pMod->cbImage);
2886	pMod->u.Manual.fCanDoQuick = K_TRUE;
2887	}
2888	pMod->u.Manual.enmState = KWMODSTATE_NEEDS_INIT;
2889	}
2890
2891	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_AMD64)
2892	/*
2893	* Need to register function table?
2894	*/
2895	if ( !pMod->u.Manual.fRegisteredFunctionTable
2896	&& pMod->u.Manual.cFunctions > 0)
2897	{
2898	pMod->u.Manual.fRegisteredFunctionTable = RtlAddFunctionTable(pMod->u.Manual.paFunctions,
2899	pMod->u.Manual.cFunctions,
2900	(KUPTR)pMod->u.Manual.pbLoad) != FALSE;
2901	kHlpAssert(pMod->u.Manual.fRegisteredFunctionTable);
2902	}
2903	#endif
2904
2905
2906	if (pMod->u.Manual.enmState == KWMODSTATE_NEEDS_INIT)
2907	{
2908	/*
2909	* Must do imports first, but mark our module as being initialized to avoid
2910	* endless recursion should there be a dependency loop.
2911	*/
2912	KSIZE iImp;
2913	pMod->u.Manual.enmState = KWMODSTATE_BEING_INITED;
2914
2915	for (iImp = 0; iImp < pMod->u.Manual.cImpMods; iImp++)
2916	{
2917	rc = kwLdrModuleInitTree(pMod->u.Manual.apImpMods[iImp]);
2918	if (rc != 0)
2919	return rc;
2920	}
2921
2922	/* Do TLS allocations for module init? */
2923	rc = kwLdrCallTlsAllocateAndInit(pMod);
2924	if (rc != 0)
2925	return rc;
2926	if (pMod->u.Manual.cTlsCallbacks > 0)
2927	kwLdrCallTlsCallbacks(pMod, DLL_PROCESS_ATTACH);
2928
2929	/* Finally call the entry point. */
2930	rc = kLdrModCallInit(pMod->pLdrMod, pMod->u.Manual.pbLoad, (KUPTR)pMod->hOurMod);
2931	if (rc == 0)
2932	pMod->u.Manual.enmState = KWMODSTATE_READY;
2933	else
2934	pMod->u.Manual.enmState = KWMODSTATE_INIT_FAILED;
2935	}
2936	}
2937	return rc;
2938	}
2939
2940
2941	/**
2942	* Looks up a module handle for a tool.
2943	*
2944	* @returns Referenced loader module on success, NULL on if not found.
2945	* @param pTool The tool.
2946	* @param hmod The module handle.
2947	*/
2948	static PKWMODULE kwToolLocateModuleByHandle(PKWTOOL pTool, HMODULE hmod)
2949	{
2950	KUPTR const uHMod = (KUPTR)hmod;
2951	PKWMODULE *papMods;
2952	KU32 iEnd;
2953	KU32 i;
2954	PKWDYNLOAD pDynLoad;
2955
2956	/* The executable. */
2957	if ( hmod == NULL
2958	\|\| pTool->u.Sandboxed.pExe->hOurMod == hmod)
2959	return kwLdrModuleRetain(pTool->u.Sandboxed.pExe);
2960
2961	/*
2962	* Binary lookup using the module table.
2963	*/
2964	papMods = pTool->u.Sandboxed.papModules;
2965	iEnd = pTool->u.Sandboxed.cModules;
2966	if (iEnd)
2967	{
2968	KU32 iStart = 0;
2969	i = iEnd / 2;
2970	for (;;)
2971	{
2972	KUPTR const uHModThis = (KUPTR)papMods[i]->hOurMod;
2973	if (uHMod < uHModThis)
2974	{
2975	iEnd = i--;
2976	if (iStart <= i)
2977	{ }
2978	else
2979	break;
2980	}
2981	else if (uHMod != uHModThis)
2982	{
2983	iStart = ++i;
2984	if (i < iEnd)
2985	{ }
2986	else
2987	break;
2988	}
2989	else
2990	return kwLdrModuleRetain(papMods[i]);
2991
2992	i = iStart + (iEnd - iStart) / 2;
2993	}
2994
2995	#ifndef NDEBUG
2996	iStart = pTool->u.Sandboxed.cModules;
2997	while (--iStart > 0)
2998	kHlpAssert((KUPTR)papMods[iStart]->hOurMod != uHMod);
2999	kHlpAssert(i == 0 \|\| (KUPTR)papMods[i - 1]->hOurMod < uHMod);
3000	kHlpAssert(i == pTool->u.Sandboxed.cModules \|\| (KUPTR)papMods[i]->hOurMod > uHMod);
3001	#endif
3002	}
3003
3004	/*
3005	* Dynamically loaded images.
3006	*/
3007	for (pDynLoad = pTool->u.Sandboxed.pDynLoadHead; pDynLoad != NULL; pDynLoad = pDynLoad->pNext)
3008	if (pDynLoad->hmod == hmod)
3009	{
3010	if (pDynLoad->pMod)
3011	return kwLdrModuleRetain(pDynLoad->pMod);
3012	KWFS_TODO();
3013	return NULL;
3014	}
3015
3016	return NULL;
3017	}
3018
3019	/**
3020	* Adds the given module to the tool import table.
3021	*
3022	* @returns 0 on success, non-zero on failure.
3023	* @param pTool The tool.
3024	* @param pMod The module.
3025	*/
3026	static int kwToolAddModule(PKWTOOL pTool, PKWMODULE pMod)
3027	{
3028	/*
3029	* Binary lookup. Locating the right slot for it, return if already there.
3030	*/
3031	KUPTR const uHMod = (KUPTR)pMod->hOurMod;
3032	PKWMODULE *papMods = pTool->u.Sandboxed.papModules;
3033	KU32 iEnd = pTool->u.Sandboxed.cModules;
3034	KU32 i;
3035	if (iEnd)
3036	{
3037	KU32 iStart = 0;
3038	i = iEnd / 2;
3039	for (;;)
3040	{
3041	KUPTR const uHModThis = (KUPTR)papMods[i]->hOurMod;
3042	if (uHMod < uHModThis)
3043	{
3044	iEnd = i;
3045	if (iStart < i)
3046	{ }
3047	else
3048	break;
3049	}
3050	else if (uHMod != uHModThis)
3051	{
3052	iStart = ++i;
3053	if (i < iEnd)
3054	{ }
3055	else
3056	break;
3057	}
3058	else
3059	{
3060	/* Already there in the table. */
3061	return 0;
3062	}
3063
3064	i = iStart + (iEnd - iStart) / 2;
3065	}
3066	#ifndef NDEBUG
3067	iStart = pTool->u.Sandboxed.cModules;
3068	while (--iStart > 0)
3069	{
3070	kHlpAssert(papMods[iStart] != pMod);
3071	kHlpAssert((KUPTR)papMods[iStart]->hOurMod != uHMod);
3072	}
3073	kHlpAssert(i == 0 \|\| (KUPTR)papMods[i - 1]->hOurMod < uHMod);
3074	kHlpAssert(i == pTool->u.Sandboxed.cModules \|\| (KUPTR)papMods[i]->hOurMod > uHMod);
3075	#endif
3076	}
3077	else
3078	i = 0;
3079
3080	/*
3081	* Grow the table?
3082	*/
3083	if ((pTool->u.Sandboxed.cModules % 16) == 0)
3084	{
3085	void pvNew = kHlpRealloc(papMods, sizeof(papMods[0]) (pTool->u.Sandboxed.cModules + 16));
3086	if (!pvNew)
3087	return KERR_NO_MEMORY;
3088	pTool->u.Sandboxed.papModules = papMods = (PKWMODULE *)pvNew;
3089	}
3090
3091	/* Insert it. */
3092	if (i != pTool->u.Sandboxed.cModules)
3093	kHlpMemMove(&papMods[i + 1], &papMods[i], (pTool->u.Sandboxed.cModules - i) * sizeof(papMods[0]));
3094	papMods[i] = kwLdrModuleRetain(pMod);
3095	pTool->u.Sandboxed.cModules++;
3096	KW_LOG(("kwToolAddModule: %u modules after adding %p=%s\n", pTool->u.Sandboxed.cModules, uHMod, pMod->pszPath));
3097	return 0;
3098	}
3099
3100
3101	/**
3102	* Adds the given module and all its imports to the
3103	*
3104	* @returns 0 on success, non-zero on failure.
3105	* @param pTool The tool.
3106	* @param pMod The module.
3107	*/
3108	static int kwToolAddModuleAndImports(PKWTOOL pTool, PKWMODULE pMod)
3109	{
3110	int rc = kwToolAddModule(pTool, pMod);
3111	if (!pMod->fNative && rc == 0)
3112	{
3113	KSIZE iImp = pMod->u.Manual.cImpMods;
3114	while (iImp-- > 0)
3115	{
3116	rc = kwToolAddModuleAndImports(pTool, pMod->u.Manual.apImpMods[iImp]);
3117	if (rc == 0)
3118	{ }
3119	else
3120	break;
3121	}
3122	}
3123	return 0;
3124	}
3125
3126
3127	/**
3128	* Creates a tool entry and inserts it.
3129	*
3130	* @returns Pointer to the tool entry. NULL on failure.
3131	* @param pToolFsObj The file object of the tool. The created tool
3132	* will be associated with it.
3133	*
3134	* A reference is donated by the caller and must be
3135	* released.
3136	* @param pszSearchPath The PATH environment variable value, or NULL.
3137	*/
3138	static PKWTOOL kwToolEntryCreate(PKFSOBJ pToolFsObj, const char *pszSearchPath)
3139	{
3140	KSIZE cwcPath = pToolFsObj->cwcParent + pToolFsObj->cwcName + 1;
3141	KSIZE cbPath = pToolFsObj->cchParent + pToolFsObj->cchName + 1;
3142	PKWTOOL pTool = (PKWTOOL)kFsCacheObjAddUserData(g_pFsCache, pToolFsObj, KW_DATA_KEY_TOOL,
3143	sizeof(pTool) + cwcPath sizeof(wchar_t) + cbPath);
3144	if (pTool)
3145	{
3146	KBOOL fRc;
3147	pTool->pwszPath = (wchar_t const *)(pTool + 1);
3148	fRc = kFsCacheObjGetFullPathW(pToolFsObj, (wchar_t *)pTool->pwszPath, cwcPath, '\\');
3149	kHlpAssert(fRc); K_NOREF(fRc);
3150
3151	pTool->pszPath = (char const *)&pTool->pwszPath[cwcPath];
3152	fRc = kFsCacheObjGetFullPathA(pToolFsObj, (char *)pTool->pszPath, cbPath, '\\');
3153	kHlpAssert(fRc);
3154
3155	pTool->enmType = KWTOOLTYPE_SANDBOXED;
3156	pTool->u.Sandboxed.pExe = kwLdrModuleCreateNonNative(pTool->pszPath, kwStrHash(pTool->pszPath), K_TRUE /fExe/,
3157	NULL /pEexeMod/, pszSearchPath);
3158	if (pTool->u.Sandboxed.pExe)
3159	{
3160	int rc = kwLdrModuleQueryMainEntrypoint(pTool->u.Sandboxed.pExe, &pTool->u.Sandboxed.uMainAddr);
3161	if (rc == 0)
3162	{
3163	if (kHlpStrICompAscii(pToolFsObj->pszName, "cl.exe") == 0)
3164	pTool->u.Sandboxed.enmHint = KWTOOLHINT_VISUAL_CPP_CL;
3165	else if (kHlpStrICompAscii(pToolFsObj->pszName, "link.exe") == 0)
3166	pTool->u.Sandboxed.enmHint = KWTOOLHINT_VISUAL_CPP_LINK;
3167	else
3168	pTool->u.Sandboxed.enmHint = KWTOOLHINT_NONE;
3169	kwToolAddModuleAndImports(pTool, pTool->u.Sandboxed.pExe);
3170	}
3171	else
3172	{
3173	kwErrPrintf("Failed to get entrypoint for '%s': %u\n", pTool->pszPath, rc);
3174	kwLdrModuleRelease(pTool->u.Sandboxed.pExe);
3175	pTool->u.Sandboxed.pExe = NULL;
3176	pTool->enmType = KWTOOLTYPE_EXEC;
3177	}
3178	}
3179	else
3180	pTool->enmType = KWTOOLTYPE_EXEC;
3181
3182	kFsCacheObjRelease(g_pFsCache, pToolFsObj);
3183	g_cTools++;
3184	return pTool;
3185	}
3186	kFsCacheObjRelease(g_pFsCache, pToolFsObj);
3187	return NULL;
3188	}
3189
3190
3191	/**
3192	* Looks up the given tool, creating a new tool table entry if necessary.
3193	*
3194	* @returns Pointer to the tool entry. NULL on failure (fully bitched).
3195	* @param pszExe The executable for the tool (not normalized).
3196	* @param cEnvVars Number of environment varibles.
3197	* @param papszEnvVars Environment variables. For getting the PATH.
3198	*/
3199	static PKWTOOL kwToolLookup(const char pszExe, KU32 cEnvVars, const char *papszEnvVars)
3200	{
3201	/*
3202	* We associate the tools instances with the file system objects.
3203	*
3204	* We'd like to do the lookup without invaliding the volatile parts of the
3205	* cache, thus the double lookup here. The cache gets invalidate later on.
3206	*/
3207	KFSLOOKUPERROR enmError;
3208	PKFSOBJ pToolFsObj = kFsCacheLookupA(g_pFsCache, pszExe, &enmError);
3209	if ( !pToolFsObj
3210	\|\| pToolFsObj->bObjType != KFSOBJ_TYPE_FILE)
3211	{
3212	kFsCacheInvalidateCustomBoth(g_pFsCache);
3213	pToolFsObj = kFsCacheLookupA(g_pFsCache, pszExe, &enmError);
3214	}
3215	if (pToolFsObj)
3216	{
3217	if (pToolFsObj->bObjType == KFSOBJ_TYPE_FILE)
3218	{
3219	const char *pszSearchPath;
3220	PKWTOOL pTool = (PKWTOOL)kFsCacheObjGetUserData(g_pFsCache, pToolFsObj, KW_DATA_KEY_TOOL);
3221	if (pTool)
3222	{
3223	kFsCacheObjRelease(g_pFsCache, pToolFsObj);
3224	return pTool;
3225	}
3226
3227	/*
3228	* Need to create a new tool.
3229	*/
3230	pszSearchPath = NULL;
3231	while (cEnvVars-- > 0)
3232	if (_strnicmp(papszEnvVars[cEnvVars], "PATH=", 5) == 0)
3233	{
3234	pszSearchPath = &papszEnvVars[cEnvVars][5];
3235	break;
3236	}
3237
3238	pTool = kwToolEntryCreate(pToolFsObj, pszSearchPath);
3239	if (pTool)
3240	return pTool;
3241
3242	kwErrPrintf("kwToolLookup(%s) -> NULL: kwToolEntryCreate failed\n", pszExe);
3243	}
3244	else
3245	{
3246	kFsCacheObjRelease(g_pFsCache, pToolFsObj);
3247	kwErrPrintf("kwToolLookup(%s) -> NULL: not file (bObjType=%d fFlags=%#x uCacheGen=%u auGenerationsMissing=[%u,%u])\n",
3248	pszExe, pToolFsObj->bObjType, pToolFsObj->fFlags, pToolFsObj->uCacheGen,
3249	g_pFsCache->auGenerationsMissing[0], g_pFsCache->auGenerationsMissing[1]);
3250	}
3251	}
3252	else
3253	kwErrPrintf("kwToolLookup(%s) -> NULL: enmError=%d\n", pszExe, enmError);
3254	return NULL;
3255	}
3256
3257
3258
3259	/*
3260	*
3261	* File system cache.
3262	* File system cache.
3263	* File system cache.
3264	*
3265	*/
3266
3267
3268	/**
3269	* This is for kDep.
3270	*/
3271	int kwFsPathExists(const char *pszPath)
3272	{
3273	BirdTimeSpec_T TsIgnored;
3274	KFSLOOKUPERROR enmError;
3275	PKFSOBJ pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszPath, &enmError);
3276	if (pFsObj)
3277	{
3278	kFsCacheObjRelease(g_pFsCache, pFsObj);
3279	return 1;
3280	}
3281	return birdStatModTimeOnly(pszPath, &TsIgnored, 1) == 0;
3282	}
3283
3284
3285	/* duplicated in dir-nt-bird.c */
3286	void nt_fullpath_cached(const char pszPath, char pszFull, size_t cbFull)
3287	{
3288	KFSLOOKUPERROR enmError;
3289	PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
3290	if (pPathObj)
3291	{
3292	KSIZE off = pPathObj->cchParent;
3293	if (off > 0)
3294	{
3295	KSIZE offEnd = off + pPathObj->cchName;
3296	if (offEnd < cbFull)
3297	{
3298	PKFSDIR pAncestor;
3299
3300	pszFull[off + pPathObj->cchName] = '\0';
3301	memcpy(&pszFull[off], pPathObj->pszName, pPathObj->cchName);
3302
3303	for (pAncestor = pPathObj->pParent; off > 0; pAncestor = pAncestor->Obj.pParent)
3304	{
3305	kHlpAssert(off > 1);
3306	kHlpAssert(pAncestor != NULL);
3307	kHlpAssert(pAncestor->Obj.cchName > 0);
3308	pszFull[--off] = '/';
3309	off -= pAncestor->Obj.cchName;
3310	kHlpAssert(pAncestor->Obj.cchParent == off);
3311	memcpy(&pszFull[off], pAncestor->Obj.pszName, pAncestor->Obj.cchName);
3312	}
3313	kFsCacheObjRelease(g_pFsCache, pPathObj);
3314	return;
3315	}
3316	}
3317	else
3318	{
3319	if ((size_t)pPathObj->cchName + 1 < cbFull)
3320	{
3321	memcpy(pszFull, pPathObj->pszName, pPathObj->cchName);
3322	pszFull[pPathObj->cchName] = '/';
3323	pszFull[pPathObj->cchName + 1] = '\0';
3324
3325	kFsCacheObjRelease(g_pFsCache, pPathObj);
3326	return;
3327	}
3328	}
3329
3330	/* do fallback. */
3331	kHlpAssertFailed();
3332	kFsCacheObjRelease(g_pFsCache, pPathObj);
3333	}
3334
3335	nt_fullpath(pszPath, pszFull, cbFull);
3336	}
3337
3338
3339	/**
3340	* Helper for getting the extension of a UTF-16 path.
3341	*
3342	* @returns Pointer to the extension or the terminator.
3343	* @param pwszPath The path.
3344	* @param pcwcExt Where to return the length of the extension.
3345	*/
3346	static wchar_t const kwFsPathGetExtW(wchar_t const pwszPath, KSIZE *pcwcExt)
3347	{
3348	wchar_t const *pwszName = pwszPath;
3349	wchar_t const *pwszExt = NULL;
3350	for (;;)
3351	{
3352	wchar_t const wc = *pwszPath++;
3353	if (wc == '.')
3354	pwszExt = pwszPath;
3355	else if (wc == '/' \|\| wc == '\\' \|\| wc == ':')
3356	{
3357	pwszName = pwszPath;
3358	pwszExt = NULL;
3359	}
3360	else if (wc == '\0')
3361	{
3362	if (pwszExt)
3363	{
3364	*pcwcExt = pwszPath - pwszExt - 1;
3365	return pwszExt;
3366	}
3367	*pcwcExt = 0;
3368	return pwszPath - 1;
3369	}
3370	}
3371	}
3372
3373
3374
3375	/**
3376	* Parses the argument string passed in as pszSrc.
3377	*
3378	* @returns size of the processed arguments.
3379	* @param pszSrc Pointer to the commandline that's to be parsed.
3380	* @param pcArgs Where to return the number of arguments.
3381	* @param argv Pointer to argument vector to put argument pointers in. NULL allowed.
3382	* @param pchPool Pointer to memory pchPool to put the arguments into. NULL allowed.
3383	*
3384	* @remarks Lifted from startuphacks-win.c
3385	*/
3386	static int parse_args(const char pszSrc, int pcArgs, char *argv, char pchPool)
3387	{
3388	int bs;
3389	char chQuote;
3390	char *pfFlags;
3391	int cbArgs;
3392	int cArgs;
3393
3394	#define PUTC(c) do { ++cbArgs; if (pchPool != NULL) *pchPool++ = (c); } while (0)
3395	#define PUTV do { ++cArgs; if (argv != NULL) *argv++ = pchPool; } while (0)
3396	#define WHITE(c) ((c) == ' ' \|\| (c) == '\t')
3397
3398	#define _ARG_DQUOTE 0x01 /* Argument quoted (") */
3399	#define _ARG_RESPONSE 0x02 /* Argument read from response file */
3400	#define _ARG_WILDCARD 0x04 /* Argument expanded from wildcard */
3401	#define _ARG_ENV 0x08 /* Argument from environment */
3402	#define _ARG_NONZERO 0x80 /* Always set, to avoid end of string */
3403
3404	cArgs = 0;
3405	cbArgs = 0;
3406
3407	#if 0
3408	/* argv[0] */
3409	PUTC((char)_ARG_NONZERO);
3410	PUTV;
3411	for (;;)
3412	{
3413	PUTC(*pszSrc);
3414	if (*pszSrc == 0)
3415	break;
3416	++pszSrc;
3417	}
3418	++pszSrc;
3419	#endif
3420
3421	for (;;)
3422	{
3423	while (WHITE(*pszSrc))
3424	++pszSrc;
3425	if (*pszSrc == 0)
3426	break;
3427	pfFlags = pchPool;
3428	PUTC((char)_ARG_NONZERO);
3429	PUTV;
3430	bs = 0; chQuote = 0;
3431	for (;;)
3432	{
3433	if (!chQuote ? (pszSrc == '"' /\|\| pszSrc == '\''/) : *pszSrc == chQuote)
3434	{
3435	while (bs >= 2)
3436	{
3437	PUTC('\\');
3438	bs -= 2;
3439	}
3440	if (bs & 1)
3441	PUTC(*pszSrc);
3442	else
3443	{
3444	chQuote = chQuote ? 0 : *pszSrc;
3445	if (pfFlags != NULL)
3446	*pfFlags \|= _ARG_DQUOTE;
3447	}
3448	bs = 0;
3449	}
3450	else if (*pszSrc == '\\')
3451	++bs;
3452	else
3453	{
3454	while (bs != 0)
3455	{
3456	PUTC('\\');
3457	--bs;
3458	}
3459	if (pszSrc == 0 \|\| (WHITE(pszSrc) && !chQuote))
3460	break;
3461	PUTC(*pszSrc);
3462	}
3463	++pszSrc;
3464	}
3465	PUTC(0);
3466	}
3467
3468	*pcArgs = cArgs;
3469	return cbArgs;
3470	}
3471
3472
3473
3474
3475	/*
3476	*
3477	* Process and thread related APIs.
3478	* Process and thread related APIs.
3479	* Process and thread related APIs.
3480	*
3481	*/
3482
3483	/** Common worker for ExitProcess(), exit() and friends. */
3484	static void WINAPI kwSandboxDoExit(int uExitCode)
3485	{
3486	if (g_Sandbox.idMainThread == GetCurrentThreadId())
3487	{
3488	PNT_TIB pTib = (PNT_TIB)NtCurrentTeb();
3489
3490	g_Sandbox.rcExitCode = (int)uExitCode;
3491
3492	/* Before we jump, restore the TIB as we're not interested in any
3493	exception chain stuff installed by the sandboxed executable. */
3494	*pTib = g_Sandbox.TibMainThread;
3495	pTib->ExceptionList = g_Sandbox.pOutXcptListHead;
3496
3497	longjmp(g_Sandbox.JmpBuf, 1);
3498	}
3499	KWFS_TODO();
3500	}
3501
3502
3503	/** ExitProcess replacement. */
3504	static void WINAPI kwSandbox_Kernel32_ExitProcess(UINT uExitCode)
3505	{
3506	KW_LOG(("kwSandbox_Kernel32_ExitProcess: %u\n", uExitCode));
3507	kwSandboxDoExit((int)uExitCode);
3508	}
3509
3510
3511	/** ExitProcess replacement. */
3512	static BOOL WINAPI kwSandbox_Kernel32_TerminateProcess(HANDLE hProcess, UINT uExitCode)
3513	{
3514	if (hProcess == GetCurrentProcess())
3515	kwSandboxDoExit(uExitCode);
3516	KWFS_TODO();
3517	return TerminateProcess(hProcess, uExitCode);
3518	}
3519
3520
3521	/** Normal CRT exit(). */
3522	static void __cdecl kwSandbox_msvcrt_exit(int rcExitCode)
3523	{
3524	KW_LOG(("kwSandbox_msvcrt_exit: %d\n", rcExitCode));
3525	kwSandboxDoExit(rcExitCode);
3526	}
3527
3528
3529	/** Quick CRT _exit(). */
3530	static void __cdecl kwSandbox_msvcrt__exit(int rcExitCode)
3531	{
3532	/* Quick. */
3533	KW_LOG(("kwSandbox_msvcrt__exit %d\n", rcExitCode));
3534	kwSandboxDoExit(rcExitCode);
3535	}
3536
3537
3538	/** Return to caller CRT _cexit(). */
3539	static void __cdecl kwSandbox_msvcrt__cexit(int rcExitCode)
3540	{
3541	KW_LOG(("kwSandbox_msvcrt__cexit: %d\n", rcExitCode));
3542	kwSandboxDoExit(rcExitCode);
3543	}
3544
3545
3546	/** Quick return to caller CRT _c_exit(). */
3547	static void __cdecl kwSandbox_msvcrt__c_exit(int rcExitCode)
3548	{
3549	KW_LOG(("kwSandbox_msvcrt__c_exit: %d\n", rcExitCode));
3550	kwSandboxDoExit(rcExitCode);
3551	}
3552
3553
3554	/** Runtime error and exit _amsg_exit(). */
3555	static void __cdecl kwSandbox_msvcrt__amsg_exit(int iMsgNo)
3556	{
3557	KW_LOG(("\nRuntime error #%u!\n", iMsgNo));
3558	kwSandboxDoExit(255);
3559	}
3560
3561
3562	/** CRT - terminate(). */
3563	static void __cdecl kwSandbox_msvcrt_terminate(void)
3564	{
3565	KW_LOG(("\nRuntime - terminate!\n"));
3566	kwSandboxDoExit(254);
3567	}
3568
3569
3570	/** CRT - _onexit */
3571	static _onexit_t __cdecl kwSandbox_msvcrt__onexit(_onexit_t pfnFunc)
3572	{
3573	//if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
3574	{
3575	PKWEXITCALLACK pCallback;
3576	KW_LOG(("_onexit(%p)\n", pfnFunc));
3577	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3578
3579	pCallback = kHlpAlloc(sizeof(*pCallback));
3580	if (pCallback)
3581	{
3582	pCallback->pfnCallback = pfnFunc;
3583	pCallback->fAtExit = K_FALSE;
3584	pCallback->pNext = g_Sandbox.pExitCallbackHead;
3585	g_Sandbox.pExitCallbackHead = pCallback;
3586	return pfnFunc;
3587	}
3588	return NULL;
3589	}
3590	KW_LOG(("_onexit(%p) - IGNORED\n", pfnFunc));
3591	return pfnFunc;
3592	}
3593
3594
3595	/** CRT - atexit */
3596	static int __cdecl kwSandbox_msvcrt_atexit(int (__cdecl *pfnFunc)(void))
3597	{
3598	//if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
3599	{
3600	PKWEXITCALLACK pCallback;
3601	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3602	KW_LOG(("atexit(%p)\n", pfnFunc));
3603
3604	pCallback = kHlpAlloc(sizeof(*pCallback));
3605	if (pCallback)
3606	{
3607	pCallback->pfnCallback = (_onexit_t)pfnFunc;
3608	pCallback->fAtExit = K_TRUE;
3609	pCallback->pNext = g_Sandbox.pExitCallbackHead;
3610	g_Sandbox.pExitCallbackHead = pCallback;
3611	return 0;
3612	}
3613	return -1;
3614	}
3615	KW_LOG(("atexit(%p) - IGNORED!\n", pfnFunc));
3616	return 0;
3617	}
3618
3619
3620	/** Kernel32 - SetConsoleCtrlHandler(). */
3621	static BOOL WINAPI kwSandbox_Kernel32_SetConsoleCtrlHandler(PHANDLER_ROUTINE pfnHandler, BOOL fAdd)
3622	{
3623	KW_LOG(("SetConsoleCtrlHandler(%p, %d) - ignoring\n"));
3624	return TRUE;
3625	}
3626
3627
3628	/** The CRT internal __getmainargs() API. */
3629	static int __cdecl kwSandbox_msvcrt___getmainargs(int pargc, char pargv, char *penvp,
3630	int dowildcard, int const *piNewMode)
3631	{
3632	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3633	*pargc = g_Sandbox.cArgs;
3634	*pargv = g_Sandbox.papszArgs;
3635	*penvp = g_Sandbox.environ;
3636
3637	/** @todo startinfo points at a newmode (setmode) value. */
3638	return 0;
3639	}
3640
3641
3642	/** The CRT internal __wgetmainargs() API. */
3643	static int __cdecl kwSandbox_msvcrt___wgetmainargs(int pargc, wchar_t pargv, wchar_t *penvp,
3644	int dowildcard, int const *piNewMode)
3645	{
3646	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3647	*pargc = g_Sandbox.cArgs;
3648	*pargv = g_Sandbox.papwszArgs;
3649	*penvp = g_Sandbox.wenviron;
3650
3651	/** @todo startinfo points at a newmode (setmode) value. */
3652	return 0;
3653	}
3654
3655
3656
3657	/** Kernel32 - GetCommandLineA() */
3658	static LPCSTR /LPSTR/ WINAPI kwSandbox_Kernel32_GetCommandLineA(VOID)
3659	{
3660	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3661	return g_Sandbox.pszCmdLine;
3662	}
3663
3664
3665	/** Kernel32 - GetCommandLineW() */
3666	static LPCWSTR /LPWSTR/ WINAPI kwSandbox_Kernel32_GetCommandLineW(VOID)
3667	{
3668	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3669	return g_Sandbox.pwszCmdLine;
3670	}
3671
3672
3673	/** Kernel32 - GetStartupInfoA() */
3674	static VOID WINAPI kwSandbox_Kernel32_GetStartupInfoA(LPSTARTUPINFOA pStartupInfo)
3675	{
3676	KW_LOG(("GetStartupInfoA\n"));
3677	GetStartupInfoA(pStartupInfo);
3678	pStartupInfo->lpReserved = NULL;
3679	pStartupInfo->lpTitle = NULL;
3680	pStartupInfo->lpReserved2 = NULL;
3681	pStartupInfo->cbReserved2 = 0;
3682	}
3683
3684
3685	/** Kernel32 - GetStartupInfoW() */
3686	static VOID WINAPI kwSandbox_Kernel32_GetStartupInfoW(LPSTARTUPINFOW pStartupInfo)
3687	{
3688	KW_LOG(("GetStartupInfoW\n"));
3689	GetStartupInfoW(pStartupInfo);
3690	pStartupInfo->lpReserved = NULL;
3691	pStartupInfo->lpTitle = NULL;
3692	pStartupInfo->lpReserved2 = NULL;
3693	pStartupInfo->cbReserved2 = 0;
3694	}
3695
3696
3697	/** CRT - __p___argc(). */
3698	static int * __cdecl kwSandbox_msvcrt___p___argc(void)
3699	{
3700	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3701	return &g_Sandbox.cArgs;
3702	}
3703
3704
3705	/** CRT - __p___argv(). */
3706	static char *** __cdecl kwSandbox_msvcrt___p___argv(void)
3707	{
3708	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3709	return &g_Sandbox.papszArgs;
3710	}
3711
3712
3713	/** CRT - __p___sargv(). */
3714	static wchar_t *** __cdecl kwSandbox_msvcrt___p___wargv(void)
3715	{
3716	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3717	return &g_Sandbox.papwszArgs;
3718	}
3719
3720
3721	/** CRT - __p__acmdln(). */
3722	static char ** __cdecl kwSandbox_msvcrt___p__acmdln(void)
3723	{
3724	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3725	return (char **)&g_Sandbox.pszCmdLine;
3726	}
3727
3728
3729	/** CRT - __p__acmdln(). */
3730	static wchar_t ** __cdecl kwSandbox_msvcrt___p__wcmdln(void)
3731	{
3732	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3733	return &g_Sandbox.pwszCmdLine;
3734	}
3735
3736
3737	/** CRT - __p__pgmptr(). */
3738	static char ** __cdecl kwSandbox_msvcrt___p__pgmptr(void)
3739	{
3740	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3741	return &g_Sandbox.pgmptr;
3742	}
3743
3744
3745	/** CRT - __p__wpgmptr(). */
3746	static wchar_t ** __cdecl kwSandbox_msvcrt___p__wpgmptr(void)
3747	{
3748	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3749	return &g_Sandbox.wpgmptr;
3750	}
3751
3752
3753	/** CRT - _get_pgmptr(). */
3754	static errno_t __cdecl kwSandbox_msvcrt__get_pgmptr(char **ppszValue)
3755	{
3756	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3757	*ppszValue = g_Sandbox.pgmptr;
3758	return 0;
3759	}
3760
3761
3762	/** CRT - _get_wpgmptr(). */
3763	static errno_t __cdecl kwSandbox_msvcrt__get_wpgmptr(wchar_t **ppwszValue)
3764	{
3765	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3766	*ppwszValue = g_Sandbox.wpgmptr;
3767	return 0;
3768	}
3769
3770	/** Just in case. */
3771	static void kwSandbox_msvcrt__wincmdln(void)
3772	{
3773	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3774	KWFS_TODO();
3775	}
3776
3777
3778	/** Just in case. */
3779	static void kwSandbox_msvcrt__wwincmdln(void)
3780	{
3781	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3782	KWFS_TODO();
3783	}
3784
3785	/** CreateThread interceptor. */
3786	static HANDLE WINAPI kwSandbox_Kernel32_CreateThread(LPSECURITY_ATTRIBUTES pSecAttr, SIZE_T cbStack,
3787	PTHREAD_START_ROUTINE pfnThreadProc, PVOID pvUser,
3788	DWORD fFlags, PDWORD pidThread)
3789	{
3790	HANDLE hThread = NULL;
3791	KW_LOG(("CreateThread: pSecAttr=%p (inh=%d) cbStack=%#x pfnThreadProc=%p pvUser=%p fFlags=%#x pidThread=%p\n",
3792	pSecAttr, pSecAttr ? pSecAttr->bInheritHandle : 0, cbStack, pfnThreadProc, pvUser, fFlags, pidThread));
3793	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3794	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
3795	{
3796	/* Allow link::DbgThread. */
3797	hThread = CreateThread(pSecAttr, cbStack, pfnThreadProc, pvUser, fFlags, pidThread);
3798	KW_LOG(("CreateThread -> %p, pidThread=%#x\n", hThread, pidThread ? pidThread : 0));
3799	}
3800	else
3801	KWFS_TODO();
3802	return hThread;
3803	}
3804
3805
3806	/** _beginthread - create a new thread. */
3807	static uintptr_t __cdecl kwSandbox_msvcrt__beginthread(void (__cdecl pfnThreadProc)(void ), unsigned cbStack, void *pvUser)
3808	{
3809	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3810	KWFS_TODO();
3811	return 0;
3812	}
3813
3814
3815	/** _beginthreadex - create a new thread, msvcr120.dll hack for c2.dll. */
3816	static uintptr_t __cdecl kwSandbox_msvcr120__beginthreadex(void *pvSecAttr, unsigned cbStack,
3817	unsigned (__stdcall pfnThreadProc)(void ), void *pvUser,
3818	unsigned fCreate, unsigned *pidThread)
3819	{
3820	/*
3821	* The VC++ 12 (VS 2013) compiler pass two is now threaded. Let it do
3822	* whatever it needs to.
3823	*/
3824	KW_LOG(("kwSandbox_msvcr120__beginthreadex: pvSecAttr=%p (inh=%d) cbStack=%#x pfnThreadProc=%p pvUser=%p fCreate=%#x pidThread=%p\n",
3825	pvSecAttr, pvSecAttr ? ((LPSECURITY_ATTRIBUTES)pvSecAttr)->bInheritHandle : 0, cbStack,
3826	pfnThreadProc, pvUser, fCreate, pidThread));
3827	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL)
3828	{
3829	uintptr_t rcRet;
3830	static uintptr_t (__cdecl s_pfnReal)(void , unsigned , unsigned (__stdcall )(void ), void , unsigned , unsigned );
3831	if (!s_pfnReal)
3832	{
3833	(FARPROC )&s_pfnReal = GetProcAddress(GetModuleHandleA("msvcr120.dll"), "_beginthreadex");
3834	if (!s_pfnReal)
3835	{
3836	kwErrPrintf("kwSandbox_msvcr120__beginthreadex: Failed to resolve _beginthreadex in msvcr120.dll!\n");
3837	__debugbreak();
3838	}
3839	}
3840	rcRet = s_pfnReal(pvSecAttr, cbStack, pfnThreadProc, pvUser, fCreate, pidThread);
3841	KW_LOG(("kwSandbox_msvcr120__beginthreadex: returns %p pidThread=%#x\n", rcRet, pidThread ? pidThread : -1));
3842	return rcRet;
3843	}
3844
3845	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3846	KWFS_TODO();
3847	return 0;
3848	}
3849
3850
3851	/** _beginthreadex - create a new thread. */
3852	static uintptr_t __cdecl kwSandbox_msvcrt__beginthreadex(void *pvSecAttr, unsigned cbStack,
3853	unsigned (__stdcall pfnThreadProc)(void ), void *pvUser,
3854	unsigned fCreate, unsigned *pidThread)
3855	{
3856	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3857	KWFS_TODO();
3858	return 0;
3859	}
3860
3861
3862	/*
3863	*
3864	* Environment related APIs.
3865	* Environment related APIs.
3866	* Environment related APIs.
3867	*
3868	*/
3869
3870	/** Kernel32 - GetEnvironmentStringsA (Watcom uses this one). */
3871	static LPCH WINAPI kwSandbox_Kernel32_GetEnvironmentStringsA(void)
3872	{
3873	char *pszzEnv;
3874	char *pszCur;
3875	KSIZE cbNeeded = 1;
3876	KSIZE iVar = 0;
3877
3878	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3879
3880	/* Figure how space much we need first. */
3881	while ((pszCur = g_Sandbox.papszEnvVars[iVar++]) != NULL)
3882	cbNeeded += kHlpStrLen(pszCur) + 1;
3883
3884	/* Allocate it. */
3885	pszzEnv = kHlpAlloc(cbNeeded);
3886	if (pszzEnv)
3887	{
3888	char *psz = pszzEnv;
3889	iVar = 0;
3890	while ((pszCur = g_Sandbox.papszEnvVars[iVar++]) != NULL)
3891	{
3892	KSIZE cbCur = kHlpStrLen(pszCur) + 1;
3893	kHlpAssert((KUPTR)(&psz[cbCur] - pszzEnv) < cbNeeded);
3894	psz = (char *)kHlpMemPCopy(psz, pszCur, cbCur);
3895	}
3896	*psz++ = '\0';
3897	kHlpAssert(psz - pszzEnv == cbNeeded);
3898	}
3899
3900	KW_LOG(("GetEnvironmentStringsA -> %p [%u]\n", pszzEnv, cbNeeded));
3901	#if 0
3902	fprintf(stderr, "GetEnvironmentStringsA: %p LB %#x\n", pszzEnv, cbNeeded);
3903	pszCur = pszzEnv;
3904	iVar = 0;
3905	while (*pszCur)
3906	{
3907	fprintf(stderr, " %u:%p=%s<eos>\n\n", iVar, pszCur, pszCur);
3908	iVar++;
3909	pszCur += kHlpStrLen(pszCur) + 1;
3910	}
3911	fprintf(stderr, " %u:%p=<eos>\n\n", iVar, pszCur);
3912	pszCur++;
3913	fprintf(stderr, "ended at %p, after %u bytes (exepcted %u)\n", pszCur, pszCur - pszzEnv, cbNeeded);
3914	#endif
3915	return pszzEnv;
3916	}
3917
3918
3919	/** Kernel32 - GetEnvironmentStrings */
3920	static LPCH WINAPI kwSandbox_Kernel32_GetEnvironmentStrings(void)
3921	{
3922	KW_LOG(("GetEnvironmentStrings!\n"));
3923	return kwSandbox_Kernel32_GetEnvironmentStringsA();
3924	}
3925
3926
3927	/** Kernel32 - GetEnvironmentStringsW */
3928	static LPWCH WINAPI kwSandbox_Kernel32_GetEnvironmentStringsW(void)
3929	{
3930	wchar_t *pwszzEnv;
3931	wchar_t *pwszCur;
3932	KSIZE cwcNeeded = 1;
3933	KSIZE iVar = 0;
3934
3935	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3936
3937	/* Figure how space much we need first. */
3938	while ((pwszCur = g_Sandbox.papwszEnvVars[iVar++]) != NULL)
3939	cwcNeeded += kwUtf16Len(pwszCur) + 1;
3940
3941	/* Allocate it. */
3942	pwszzEnv = kHlpAlloc(cwcNeeded * sizeof(wchar_t));
3943	if (pwszzEnv)
3944	{
3945	wchar_t *pwsz = pwszzEnv;
3946	iVar = 0;
3947	while ((pwszCur = g_Sandbox.papwszEnvVars[iVar++]) != NULL)
3948	{
3949	KSIZE cwcCur = kwUtf16Len(pwszCur) + 1;
3950	kHlpAssert((KUPTR)(&pwsz[cwcCur] - pwszzEnv) < cwcNeeded);
3951	pwsz = (wchar_t )kHlpMemPCopy(pwsz, pwszCur, cwcCur sizeof(wchar_t));
3952	}
3953	*pwsz++ = '\0';
3954	kHlpAssert(pwsz - pwszzEnv == cwcNeeded);
3955	}
3956
3957	KW_LOG(("GetEnvironmentStringsW -> %p [%u]\n", pwszzEnv, cwcNeeded));
3958	return pwszzEnv;
3959	}
3960
3961
3962	/** Kernel32 - FreeEnvironmentStringsA */
3963	static BOOL WINAPI kwSandbox_Kernel32_FreeEnvironmentStringsA(LPCH pszzEnv)
3964	{
3965	KW_LOG(("FreeEnvironmentStringsA: %p -> TRUE\n", pszzEnv));
3966	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3967	kHlpFree(pszzEnv);
3968	return TRUE;
3969	}
3970
3971
3972	/** Kernel32 - FreeEnvironmentStringsW */
3973	static BOOL WINAPI kwSandbox_Kernel32_FreeEnvironmentStringsW(LPWCH pwszzEnv)
3974	{
3975	KW_LOG(("FreeEnvironmentStringsW: %p -> TRUE\n", pwszzEnv));
3976	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
3977	kHlpFree(pwszzEnv);
3978	return TRUE;
3979	}
3980
3981
3982	/**
3983	* Grows the environment vectors (KWSANDBOX::environ, KWSANDBOX::papszEnvVars,
3984	* KWSANDBOX::wenviron, and KWSANDBOX::papwszEnvVars).
3985	*
3986	* @returns 0 on success, non-zero on failure.
3987	* @param pSandbox The sandbox.
3988	* @param cMin Minimum size, including terminator.
3989	*/
3990	static int kwSandboxGrowEnv(PKWSANDBOX pSandbox, KSIZE cMin)
3991	{
3992	void *pvNew;
3993	KSIZE const cOld = pSandbox->cEnvVarsAllocated;
3994	KSIZE cNew = cOld + 256;
3995	while (cNew < cMin)
3996	cNew += 256;
3997
3998	pvNew = kHlpRealloc(pSandbox->environ, cNew * sizeof(pSandbox->environ[0]));
3999	if (pvNew)
4000	{
4001	pSandbox->environ = (char **)pvNew;
4002	pSandbox->environ[cOld] = NULL;
4003
4004	pvNew = kHlpRealloc(pSandbox->papszEnvVars, cNew * sizeof(pSandbox->papszEnvVars[0]));
4005	if (pvNew)
4006	{
4007	pSandbox->papszEnvVars = (char **)pvNew;
4008	pSandbox->papszEnvVars[cOld] = NULL;
4009
4010	pvNew = kHlpRealloc(pSandbox->wenviron, cNew * sizeof(pSandbox->wenviron[0]));
4011	if (pvNew)
4012	{
4013	pSandbox->wenviron = (wchar_t **)pvNew;
4014	pSandbox->wenviron[cOld] = NULL;
4015
4016	pvNew = kHlpRealloc(pSandbox->papwszEnvVars, cNew * sizeof(pSandbox->papwszEnvVars[0]));
4017	if (pvNew)
4018	{
4019	pSandbox->papwszEnvVars = (wchar_t **)pvNew;
4020	pSandbox->papwszEnvVars[cOld] = NULL;
4021
4022	pSandbox->cEnvVarsAllocated = cNew;
4023	KW_LOG(("kwSandboxGrowEnv: cNew=%d - crt: %p / %p; shadow: %p, %p\n",
4024	cNew, pSandbox->environ, pSandbox->wenviron, pSandbox->papszEnvVars, pSandbox->papwszEnvVars));
4025	return 0;
4026	}
4027	}
4028	}
4029	}
4030	kwErrPrintf("kwSandboxGrowEnv ran out of memory! cNew=%u\n", cNew);
4031	return KERR_NO_MEMORY;
4032	}
4033
4034
4035	/**
4036	* Sets an environment variable, ANSI style.
4037	*
4038	* @returns 0 on success, non-zero on failure.
4039	* @param pSandbox The sandbox.
4040	* @param pchVar The variable name.
4041	* @param cchVar The length of the name.
4042	* @param pszValue The value.
4043	*/
4044	static int kwSandboxDoSetEnvA(PKWSANDBOX pSandbox, const char pchVar, KSIZE cchVar, const char pszValue)
4045	{
4046	/* Allocate and construct the new strings. */
4047	KSIZE cchTmp = kHlpStrLen(pszValue);
4048	char pszNew = (char )kHlpAlloc(cchVar + 1 + cchTmp + 1);
4049	if (pszNew)
4050	{
4051	wchar_t *pwszNew;
4052	kHlpMemCopy(pszNew, pchVar, cchVar);
4053	pszNew[cchVar] = '=';
4054	kHlpMemCopy(&pszNew[cchVar + 1], pszValue, cchTmp);
4055	cchTmp += cchVar + 1;
4056	pszNew[cchTmp] = '\0';
4057
4058	pwszNew = kwStrToUtf16AllocN(pszNew, cchTmp);
4059	if (pwszNew)
4060	{
4061	/* Look it up. */
4062	KSIZE iVar = 0;
4063	char *pszEnv;
4064	while ((pszEnv = pSandbox->papszEnvVars[iVar]) != NULL)
4065	{
4066	if ( _strnicmp(pszEnv, pchVar, cchVar) == 0
4067	&& pszEnv[cchVar] == '=')
4068	{
4069	KW_LOG(("kwSandboxDoSetEnvA: Replacing iVar=%d: %p='%s' and %p='%ls'\n"
4070	" iVar=%d: %p='%s' and %p='%ls'\n",
4071	iVar, pSandbox->papszEnvVars[iVar], pSandbox->papszEnvVars[iVar],
4072	pSandbox->papwszEnvVars[iVar], pSandbox->papwszEnvVars[iVar],
4073	iVar, pszNew, pszNew, pwszNew, pwszNew));
4074
4075	kHlpFree(pSandbox->papszEnvVars[iVar]);
4076	pSandbox->papszEnvVars[iVar] = pszNew;
4077	pSandbox->environ[iVar] = pszNew;
4078
4079	kHlpFree(pSandbox->papwszEnvVars[iVar]);
4080	pSandbox->papwszEnvVars[iVar] = pwszNew;
4081	pSandbox->wenviron[iVar] = pwszNew;
4082	return 0;
4083	}
4084	iVar++;
4085	}
4086
4087	/* Not found, do we need to grow the table first? */
4088	if (iVar + 1 >= pSandbox->cEnvVarsAllocated)
4089	kwSandboxGrowEnv(pSandbox, iVar + 2);
4090	if (iVar + 1 < pSandbox->cEnvVarsAllocated)
4091	{
4092	KW_LOG(("kwSandboxDoSetEnvA: Adding iVar=%d: %p='%s' and %p='%ls'\n", iVar, pszNew, pszNew, pwszNew, pwszNew));
4093
4094	pSandbox->papszEnvVars[iVar + 1] = NULL;
4095	pSandbox->papszEnvVars[iVar] = pszNew;
4096	pSandbox->environ[iVar + 1] = NULL;
4097	pSandbox->environ[iVar] = pszNew;
4098
4099	pSandbox->papwszEnvVars[iVar + 1] = NULL;
4100	pSandbox->papwszEnvVars[iVar] = pwszNew;
4101	pSandbox->wenviron[iVar + 1] = NULL;
4102	pSandbox->wenviron[iVar] = pwszNew;
4103	return 0;
4104	}
4105
4106	kHlpFree(pwszNew);
4107	}
4108	kHlpFree(pszNew);
4109	}
4110	KW_LOG(("Out of memory!\n"));
4111	return 0;
4112	}
4113
4114
4115	/**
4116	* Sets an environment variable, UTF-16 style.
4117	*
4118	* @returns 0 on success, non-zero on failure.
4119	* @param pSandbox The sandbox.
4120	* @param pwcVar The variable name.
4121	* @param cwcVar The length of the name.
4122	* @param pwszValue The value.
4123	*/
4124	static int kwSandboxDoSetEnvW(PKWSANDBOX pSandbox, const wchar_t pwchVar, KSIZE cwcVar, const wchar_t pwszValue)
4125	{
4126	/* Allocate and construct the new strings. */
4127	KSIZE cwcTmp = kwUtf16Len(pwszValue);
4128	wchar_t pwszNew = (wchar_t )kHlpAlloc((cwcVar + 1 + cwcTmp + 1) * sizeof(wchar_t));
4129	if (pwszNew)
4130	{
4131	char *pszNew;
4132	kHlpMemCopy(pwszNew, pwchVar, cwcVar * sizeof(wchar_t));
4133	pwszNew[cwcVar] = '=';
4134	kHlpMemCopy(&pwszNew[cwcVar + 1], pwszValue, cwcTmp * sizeof(wchar_t));
4135	cwcTmp += cwcVar + 1;
4136	pwszNew[cwcVar] = '\0';
4137
4138	pszNew = kwUtf16ToStrAllocN(pwszNew, cwcVar);
4139	if (pszNew)
4140	{
4141	/* Look it up. */
4142	KSIZE iVar = 0;
4143	wchar_t *pwszEnv;
4144	while ((pwszEnv = pSandbox->papwszEnvVars[iVar]) != NULL)
4145	{
4146	if ( _wcsnicmp(pwszEnv, pwchVar, cwcVar) == 0
4147	&& pwszEnv[cwcVar] == '=')
4148	{
4149	KW_LOG(("kwSandboxDoSetEnvW: Replacing iVar=%d: %p='%s' and %p='%ls'\n"
4150	" iVar=%d: %p='%s' and %p='%ls'\n",
4151	iVar, pSandbox->papszEnvVars[iVar], pSandbox->papszEnvVars[iVar],
4152	pSandbox->papwszEnvVars[iVar], pSandbox->papwszEnvVars[iVar],
4153	iVar, pszNew, pszNew, pwszNew, pwszNew));
4154
4155	kHlpFree(pSandbox->papszEnvVars[iVar]);
4156	pSandbox->papszEnvVars[iVar] = pszNew;
4157	pSandbox->environ[iVar] = pszNew;
4158
4159	kHlpFree(pSandbox->papwszEnvVars[iVar]);
4160	pSandbox->papwszEnvVars[iVar] = pwszNew;
4161	pSandbox->wenviron[iVar] = pwszNew;
4162	return 0;
4163	}
4164	iVar++;
4165	}
4166
4167	/* Not found, do we need to grow the table first? */
4168	if (iVar + 1 >= pSandbox->cEnvVarsAllocated)
4169	kwSandboxGrowEnv(pSandbox, iVar + 2);
4170	if (iVar + 1 < pSandbox->cEnvVarsAllocated)
4171	{
4172	KW_LOG(("kwSandboxDoSetEnvW: Adding iVar=%d: %p='%s' and %p='%ls'\n", iVar, pszNew, pszNew, pwszNew, pwszNew));
4173
4174	pSandbox->papszEnvVars[iVar + 1] = NULL;
4175	pSandbox->papszEnvVars[iVar] = pszNew;
4176	pSandbox->environ[iVar + 1] = NULL;
4177	pSandbox->environ[iVar] = pszNew;
4178
4179	pSandbox->papwszEnvVars[iVar + 1] = NULL;
4180	pSandbox->papwszEnvVars[iVar] = pwszNew;
4181	pSandbox->wenviron[iVar + 1] = NULL;
4182	pSandbox->wenviron[iVar] = pwszNew;
4183	return 0;
4184	}
4185
4186	kHlpFree(pwszNew);
4187	}
4188	kHlpFree(pszNew);
4189	}
4190	KW_LOG(("Out of memory!\n"));
4191	return 0;
4192	}
4193
4194
4195	/** ANSI unsetenv worker. */
4196	static int kwSandboxDoUnsetEnvA(PKWSANDBOX pSandbox, const char *pchVar, KSIZE cchVar)
4197	{
4198	KSIZE iVar = 0;
4199	char *pszEnv;
4200	while ((pszEnv = pSandbox->papszEnvVars[iVar]) != NULL)
4201	{
4202	if ( _strnicmp(pszEnv, pchVar, cchVar) == 0
4203	&& pszEnv[cchVar] == '=')
4204	{
4205	KSIZE cVars = iVar;
4206	while (pSandbox->papszEnvVars[cVars])
4207	cVars++;
4208	kHlpAssert(pSandbox->papwszEnvVars[iVar] != NULL);
4209	kHlpAssert(pSandbox->papwszEnvVars[cVars] == NULL);
4210
4211	KW_LOG(("kwSandboxDoUnsetEnvA: Removing iVar=%d: %p='%s' and %p='%ls'; new cVars=%d\n", iVar,
4212	pSandbox->papszEnvVars[iVar], pSandbox->papszEnvVars[iVar],
4213	pSandbox->papwszEnvVars[iVar], pSandbox->papwszEnvVars[iVar], cVars - 1));
4214
4215	kHlpFree(pSandbox->papszEnvVars[iVar]);
4216	pSandbox->papszEnvVars[iVar] = pSandbox->papszEnvVars[cVars];
4217	pSandbox->environ[iVar] = pSandbox->papszEnvVars[cVars];
4218	pSandbox->papszEnvVars[cVars] = NULL;
4219	pSandbox->environ[cVars] = NULL;
4220
4221	kHlpFree(pSandbox->papwszEnvVars[iVar]);
4222	pSandbox->papwszEnvVars[iVar] = pSandbox->papwszEnvVars[cVars];
4223	pSandbox->wenviron[iVar] = pSandbox->papwszEnvVars[cVars];
4224	pSandbox->papwszEnvVars[cVars] = NULL;
4225	pSandbox->wenviron[cVars] = NULL;
4226	return 0;
4227	}
4228	iVar++;
4229	}
4230	return KERR_ENVVAR_NOT_FOUND;
4231	}
4232
4233
4234	/** UTF-16 unsetenv worker. */
4235	static int kwSandboxDoUnsetEnvW(PKWSANDBOX pSandbox, const wchar_t *pwcVar, KSIZE cwcVar)
4236	{
4237	KSIZE iVar = 0;
4238	wchar_t *pwszEnv;
4239	while ((pwszEnv = pSandbox->papwszEnvVars[iVar]) != NULL)
4240	{
4241	if ( _wcsnicmp(pwszEnv, pwcVar, cwcVar) == 0
4242	&& pwszEnv[cwcVar] == '=')
4243	{
4244	KSIZE cVars = iVar;
4245	while (pSandbox->papwszEnvVars[cVars])
4246	cVars++;
4247	kHlpAssert(pSandbox->papszEnvVars[iVar] != NULL);
4248	kHlpAssert(pSandbox->papszEnvVars[cVars] == NULL);
4249
4250	KW_LOG(("kwSandboxDoUnsetEnvA: Removing iVar=%d: %p='%s' and %p='%ls'; new cVars=%d\n", iVar,
4251	pSandbox->papszEnvVars[iVar], pSandbox->papszEnvVars[iVar],
4252	pSandbox->papwszEnvVars[iVar], pSandbox->papwszEnvVars[iVar], cVars - 1));
4253
4254	kHlpFree(pSandbox->papszEnvVars[iVar]);
4255	pSandbox->papszEnvVars[iVar] = pSandbox->papszEnvVars[cVars];
4256	pSandbox->environ[iVar] = pSandbox->papszEnvVars[cVars];
4257	pSandbox->papszEnvVars[cVars] = NULL;
4258	pSandbox->environ[cVars] = NULL;
4259
4260	kHlpFree(pSandbox->papwszEnvVars[iVar]);
4261	pSandbox->papwszEnvVars[iVar] = pSandbox->papwszEnvVars[cVars];
4262	pSandbox->wenviron[iVar] = pSandbox->papwszEnvVars[cVars];
4263	pSandbox->papwszEnvVars[cVars] = NULL;
4264	pSandbox->wenviron[cVars] = NULL;
4265	return 0;
4266	}
4267	iVar++;
4268	}
4269	return KERR_ENVVAR_NOT_FOUND;
4270	}
4271
4272
4273
4274	/** ANSI getenv worker. */
4275	static char kwSandboxDoGetEnvA(PKWSANDBOX pSandbox, const char pchVar, KSIZE cchVar)
4276	{
4277	KSIZE iVar = 0;
4278	char *pszEnv;
4279	while ((pszEnv = pSandbox->papszEnvVars[iVar++]) != NULL)
4280	if ( _strnicmp(pszEnv, pchVar, cchVar) == 0
4281	&& pszEnv[cchVar] == '=')
4282	return &pszEnv[cchVar + 1];
4283	return NULL;
4284	}
4285
4286
4287	/** UTF-16 getenv worker. */
4288	static wchar_t kwSandboxDoGetEnvW(PKWSANDBOX pSandbox, const wchar_t pwcVar, KSIZE cwcVar)
4289	{
4290	KSIZE iVar = 0;
4291	wchar_t *pwszEnv;
4292	while ((pwszEnv = pSandbox->papwszEnvVars[iVar++]) != NULL)
4293	if ( _wcsnicmp(pwszEnv, pwcVar, cwcVar) == 0
4294	&& pwszEnv[cwcVar] == '=')
4295	return &pwszEnv[cwcVar + 1];
4296	return NULL;
4297	}
4298
4299
4300	/** Kernel32 - GetEnvironmentVariableA() */
4301	static DWORD WINAPI kwSandbox_Kernel32_GetEnvironmentVariableA(LPCSTR pszVar, LPSTR pszValue, DWORD cbValue)
4302	{
4303	char *pszFoundValue;
4304	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4305
4306	pszFoundValue = kwSandboxDoGetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar));
4307	if (pszFoundValue)
4308	{
4309	DWORD cchRet = kwStrCopyStyle1(pszFoundValue, pszValue, cbValue);
4310	KW_LOG(("GetEnvironmentVariableA: '%s' -> %u (%s)\n", pszVar, cchRet, pszFoundValue));
4311	return cchRet;
4312	}
4313	KW_LOG(("GetEnvironmentVariableA: '%s' -> 0\n", pszVar));
4314	SetLastError(ERROR_ENVVAR_NOT_FOUND);
4315	return 0;
4316	}
4317
4318
4319	/** Kernel32 - GetEnvironmentVariableW() */
4320	static DWORD WINAPI kwSandbox_Kernel32_GetEnvironmentVariableW(LPCWSTR pwszVar, LPWSTR pwszValue, DWORD cwcValue)
4321	{
4322	wchar_t *pwszFoundValue;
4323	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4324
4325	pwszFoundValue = kwSandboxDoGetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar));
4326	if (pwszFoundValue)
4327	{
4328	DWORD cchRet = kwUtf16CopyStyle1(pwszFoundValue, pwszValue, cwcValue);
4329	KW_LOG(("GetEnvironmentVariableW: '%ls' -> %u (%ls)\n", pwszVar, cchRet, pwszFoundValue));
4330	return cchRet;
4331	}
4332	KW_LOG(("GetEnvironmentVariableW: '%ls' -> 0\n", pwszVar));
4333	SetLastError(ERROR_ENVVAR_NOT_FOUND);
4334	return 0;
4335	}
4336
4337
4338	/** Kernel32 - SetEnvironmentVariableA() */
4339	static BOOL WINAPI kwSandbox_Kernel32_SetEnvironmentVariableA(LPCSTR pszVar, LPCSTR pszValue)
4340	{
4341	int rc;
4342	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4343
4344	if (pszValue)
4345	rc = kwSandboxDoSetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar), pszValue);
4346	else
4347	{
4348	kwSandboxDoUnsetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar));
4349	rc = 0; //??
4350	}
4351	if (rc == 0)
4352	{
4353	KW_LOG(("SetEnvironmentVariableA(%s,%s) -> TRUE\n", pszVar, pszValue));
4354	return TRUE;
4355	}
4356	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4357	KW_LOG(("SetEnvironmentVariableA(%s,%s) -> FALSE!\n", pszVar, pszValue));
4358	return FALSE;
4359	}
4360
4361
4362	/** Kernel32 - SetEnvironmentVariableW() */
4363	static BOOL WINAPI kwSandbox_Kernel32_SetEnvironmentVariableW(LPCWSTR pwszVar, LPCWSTR pwszValue)
4364	{
4365	int rc;
4366	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4367
4368	if (pwszValue)
4369	rc = kwSandboxDoSetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar), pwszValue);
4370	else
4371	{
4372	kwSandboxDoUnsetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar));
4373	rc = 0; //??
4374	}
4375	if (rc == 0)
4376	{
4377	KW_LOG(("SetEnvironmentVariableA(%ls,%ls) -> TRUE\n", pwszVar, pwszValue));
4378	return TRUE;
4379	}
4380	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4381	KW_LOG(("SetEnvironmentVariableA(%ls,%ls) -> FALSE!\n", pwszVar, pwszValue));
4382	return FALSE;
4383	}
4384
4385
4386	/** Kernel32 - ExpandEnvironmentStringsA() */
4387	static DWORD WINAPI kwSandbox_Kernel32_ExpandEnvironmentStringsA(LPCSTR pszSrc, LPSTR pwszDst, DWORD cbDst)
4388	{
4389	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4390	KWFS_TODO();
4391	return 0;
4392	}
4393
4394
4395	/** Kernel32 - ExpandEnvironmentStringsW() */
4396	static DWORD WINAPI kwSandbox_Kernel32_ExpandEnvironmentStringsW(LPCWSTR pwszSrc, LPWSTR pwszDst, DWORD cbDst)
4397	{
4398	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4399	KWFS_TODO();
4400	return 0;
4401	}
4402
4403
4404	/** CRT - _putenv(). */
4405	static int __cdecl kwSandbox_msvcrt__putenv(const char *pszVarEqualValue)
4406	{
4407	int rc;
4408	char const *pszEqual;
4409	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4410
4411	pszEqual = kHlpStrChr(pszVarEqualValue, '=');
4412	if (pszEqual)
4413	{
4414	rc = kwSandboxDoSetEnvA(&g_Sandbox, pszVarEqualValue, pszEqual - pszVarEqualValue, pszEqual + 1);
4415	if (rc == 0)
4416	{ }
4417	else
4418	rc = -1;
4419	}
4420	else
4421	{
4422	kwSandboxDoUnsetEnvA(&g_Sandbox, pszVarEqualValue, kHlpStrLen(pszVarEqualValue));
4423	rc = 0;
4424	}
4425	KW_LOG(("_putenv(%s) -> %d\n", pszVarEqualValue, rc));
4426	return rc;
4427	}
4428
4429
4430	/** CRT - _wputenv(). */
4431	static int __cdecl kwSandbox_msvcrt__wputenv(const wchar_t *pwszVarEqualValue)
4432	{
4433	int rc;
4434	wchar_t const *pwszEqual;
4435	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4436
4437	pwszEqual = wcschr(pwszVarEqualValue, '=');
4438	if (pwszEqual)
4439	{
4440	rc = kwSandboxDoSetEnvW(&g_Sandbox, pwszVarEqualValue, pwszEqual - pwszVarEqualValue, pwszEqual + 1);
4441	if (rc == 0)
4442	{ }
4443	else
4444	rc = -1;
4445	}
4446	else
4447	{
4448	kwSandboxDoUnsetEnvW(&g_Sandbox, pwszVarEqualValue, kwUtf16Len(pwszVarEqualValue));
4449	rc = 0;
4450	}
4451	KW_LOG(("_wputenv(%ls) -> %d\n", pwszVarEqualValue, rc));
4452	return rc;
4453	}
4454
4455
4456	/** CRT - _putenv_s(). */
4457	static errno_t __cdecl kwSandbox_msvcrt__putenv_s(const char pszVar, const char pszValue)
4458	{
4459	char const *pszEqual;
4460	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4461
4462	pszEqual = kHlpStrChr(pszVar, '=');
4463	if (pszEqual == NULL)
4464	{
4465	if (pszValue)
4466	{
4467	int rc = kwSandboxDoSetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar), pszValue);
4468	if (rc == 0)
4469	{
4470	KW_LOG(("_putenv_s(%s,%s) -> 0\n", pszVar, pszValue));
4471	return 0;
4472	}
4473	}
4474	else
4475	{
4476	kwSandboxDoUnsetEnvA(&g_Sandbox, pszVar, kHlpStrLen(pszVar));
4477	KW_LOG(("_putenv_s(%ls,NULL) -> 0\n", pszVar));
4478	return 0;
4479	}
4480	KW_LOG(("_putenv_s(%s,%s) -> ENOMEM\n", pszVar, pszValue));
4481	return ENOMEM;
4482	}
4483	KW_LOG(("_putenv_s(%s,%s) -> EINVAL\n", pszVar, pszValue));
4484	return EINVAL;
4485	}
4486
4487
4488	/** CRT - _wputenv_s(). */
4489	static errno_t __cdecl kwSandbox_msvcrt__wputenv_s(const wchar_t pwszVar, const wchar_t pwszValue)
4490	{
4491	wchar_t const *pwszEqual;
4492	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4493
4494	pwszEqual = wcschr(pwszVar, '=');
4495	if (pwszEqual == NULL)
4496	{
4497	if (pwszValue)
4498	{
4499	int rc = kwSandboxDoSetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar), pwszValue);
4500	if (rc == 0)
4501	{
4502	KW_LOG(("_wputenv_s(%ls,%ls) -> 0\n", pwszVar, pwszValue));
4503	return 0;
4504	}
4505	}
4506	else
4507	{
4508	kwSandboxDoUnsetEnvW(&g_Sandbox, pwszVar, kwUtf16Len(pwszVar));
4509	KW_LOG(("_wputenv_s(%ls,NULL) -> 0\n", pwszVar));
4510	return 0;
4511	}
4512	KW_LOG(("_wputenv_s(%ls,%ls) -> ENOMEM\n", pwszVar, pwszValue));
4513	return ENOMEM;
4514	}
4515	KW_LOG(("_wputenv_s(%ls,%ls) -> EINVAL\n", pwszVar, pwszValue));
4516	return EINVAL;
4517	}
4518
4519
4520	/** CRT - get pointer to the __initenv variable (initial environment). */
4521	static char *** __cdecl kwSandbox_msvcrt___p___initenv(void)
4522	{
4523	KW_LOG(("__p___initenv\n"));
4524	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4525	KWFS_TODO();
4526	return &g_Sandbox.initenv;
4527	}
4528
4529
4530	/** CRT - get pointer to the __winitenv variable (initial environment). */
4531	static wchar_t *** __cdecl kwSandbox_msvcrt___p___winitenv(void)
4532	{
4533	KW_LOG(("__p___winitenv\n"));
4534	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4535	KWFS_TODO();
4536	return &g_Sandbox.winitenv;
4537	}
4538
4539
4540	/** CRT - get pointer to the _environ variable (current environment). */
4541	static char *** __cdecl kwSandbox_msvcrt___p__environ(void)
4542	{
4543	KW_LOG(("__p__environ\n"));
4544	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4545	return &g_Sandbox.environ;
4546	}
4547
4548
4549	/** CRT - get pointer to the _wenviron variable (current environment). */
4550	static wchar_t *** __cdecl kwSandbox_msvcrt___p__wenviron(void)
4551	{
4552	KW_LOG(("__p__wenviron\n"));
4553	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4554	return &g_Sandbox.wenviron;
4555	}
4556
4557
4558	/** CRT - get the _environ variable (current environment).
4559	* @remarks Not documented or prototyped? */
4560	static KUPTR /void/ __cdecl kwSandbox_msvcrt__get_environ(char ***ppapszEnviron)
4561	{
4562	KWFS_TODO(); /** @todo check the callers expectations! */
4563	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4564	*ppapszEnviron = g_Sandbox.environ;
4565	return 0;
4566	}
4567
4568
4569	/** CRT - get the _wenviron variable (current environment).
4570	* @remarks Not documented or prototyped? */
4571	static KUPTR /void/ __cdecl kwSandbox_msvcrt__get_wenviron(wchar_t ***ppapwszEnviron)
4572	{
4573	KWFS_TODO(); /** @todo check the callers expectations! */
4574	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4575	*ppapwszEnviron = g_Sandbox.wenviron;
4576	return 0;
4577	}
4578
4579
4580
4581	/*
4582	*
4583	* Loader related APIs
4584	* Loader related APIs
4585	* Loader related APIs
4586	*
4587	*/
4588
4589	/**
4590	* Kernel32 - LoadLibraryExA() worker that loads resource files and such.
4591	*/
4592	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryExA_Resource(PKWDYNLOAD pDynLoad, DWORD fFlags)
4593	{
4594	/* Load it first. */
4595	HMODULE hmod = LoadLibraryExA(pDynLoad->szRequest, NULL /hFile/, fFlags);
4596	if (hmod)
4597	{
4598	pDynLoad->hmod = hmod;
4599	pDynLoad->pMod = NULL; /* indicates special */
4600
4601	pDynLoad->pNext = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead;
4602	g_Sandbox.pTool->u.Sandboxed.pDynLoadHead = pDynLoad;
4603	KW_LOG(("LoadLibraryExA(%s,,[resource]) -> %p\n", pDynLoad->szRequest, pDynLoad->hmod));
4604	}
4605	else
4606	kHlpFree(pDynLoad);
4607	return hmod;
4608	}
4609
4610
4611	/**
4612	* Kernel32 - LoadLibraryExA() worker that deals with the api-ms-xxx modules.
4613	*/
4614	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryExA_VirtualApiModule(PKWDYNLOAD pDynLoad, DWORD fFlags)
4615	{
4616	HMODULE hmod;
4617	PKWMODULE pMod;
4618	KU32 uHashPath;
4619	KSIZE idxHash;
4620	char szNormPath[256];
4621	KSIZE cbFilename = kHlpStrLen(pDynLoad->szRequest) + 1;
4622
4623	/*
4624	* Lower case it.
4625	*/
4626	if (cbFilename <= sizeof(szNormPath))
4627	{
4628	kHlpMemCopy(szNormPath, pDynLoad->szRequest, cbFilename);
4629	_strlwr(szNormPath);
4630	}
4631	else
4632	{
4633	SetLastError(ERROR_FILENAME_EXCED_RANGE);
4634	return NULL;
4635	}
4636
4637	/*
4638	* Check if it has already been loaded so we don't create an unnecessary
4639	* loader module for it.
4640	*/
4641	uHashPath = kwStrHash(szNormPath);
4642	idxHash = uHashPath % K_ELEMENTS(g_apModules);
4643	pMod = g_apModules[idxHash];
4644	if (pMod)
4645	{
4646	do
4647	{
4648	if ( pMod->uHashPath == uHashPath
4649	&& kHlpStrComp(pMod->pszPath, szNormPath) == 0)
4650	{
4651	pDynLoad->pMod = kwLdrModuleRetain(pMod);
4652	pDynLoad->hmod = pMod->hOurMod;
4653
4654	pDynLoad->pNext = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead;
4655	g_Sandbox.pTool->u.Sandboxed.pDynLoadHead = pDynLoad;
4656	KW_LOG(("LoadLibraryExA(%s,,) -> %p [already loaded]\n", pDynLoad->szRequest, pDynLoad->hmod));
4657	return pDynLoad->hmod;
4658	}
4659	pMod = pMod->pNext;
4660	} while (pMod);
4661	}
4662
4663
4664	/*
4665	* Try load it and make a kLdr module for it.
4666	*/
4667	hmod = LoadLibraryExA(szNormPath, NULL /hFile/, fFlags);
4668	if (hmod)
4669	{
4670	PKLDRMOD pLdrMod;
4671	int rc = kLdrModOpenNativeByHandle((KUPTR)hmod, &pLdrMod);
4672	if (rc == 0)
4673	{
4674	PKWMODULE pMod = kwLdrModuleCreateForNativekLdrModule(pLdrMod, szNormPath, cbFilename, uHashPath,
4675	K_FALSE /fDoReplacements/);
4676	if (pMod)
4677	{
4678	kwToolAddModuleAndImports(g_Sandbox.pTool, pMod);
4679
4680	pDynLoad = (PKWDYNLOAD)kHlpAlloc(sizeof(pDynLoad) + cbFilename + cbFilename sizeof(wchar_t));
4681	if (pDynLoad)
4682	{
4683	pDynLoad->pMod = pMod;
4684	pDynLoad->hmod = hmod;
4685
4686	pDynLoad->pNext = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead;
4687	g_Sandbox.pTool->u.Sandboxed.pDynLoadHead = pDynLoad;
4688	KW_LOG(("LoadLibraryExA(%s,,) -> %p\n", pDynLoad->szRequest, pDynLoad->hmod));
4689	return hmod;
4690	}
4691
4692	KWFS_TODO();
4693	}
4694	else
4695	KWFS_TODO();
4696	}
4697	else
4698	KWFS_TODO();
4699	}
4700	kHlpFree(pDynLoad);
4701	return hmod;
4702	}
4703
4704
4705	/** Kernel32 - LoadLibraryExA() */
4706	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryExA(LPCSTR pszFilename, HANDLE hFile, DWORD fFlags)
4707	{
4708	KSIZE cchFilename = kHlpStrLen(pszFilename);
4709	const char *pszSearchPath;
4710	PKWDYNLOAD pDynLoad;
4711	PKWMODULE pMod;
4712	int rc;
4713	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4714
4715	/*
4716	* Deal with a couple of extremely unlikely special cases right away.
4717	*/
4718	if ( ( !(fFlags & LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE)
4719	\|\| (fFlags & LOAD_LIBRARY_AS_IMAGE_RESOURCE))
4720	&& (hFile == NULL \|\| hFile == INVALID_HANDLE_VALUE) )
4721	{ /* likely */ }
4722	else
4723	{
4724	KWFS_TODO();
4725	return LoadLibraryExA(pszFilename, hFile, fFlags);
4726	}
4727
4728	/*
4729	* Check if we've already got a dynload entry for this one.
4730	*/
4731	for (pDynLoad = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead; pDynLoad; pDynLoad = pDynLoad->pNext)
4732	if ( pDynLoad->cchRequest == cchFilename
4733	&& kHlpMemComp(pDynLoad->szRequest, pszFilename, cchFilename) == 0)
4734	{
4735	if (pDynLoad->pMod)
4736	rc = kwLdrModuleInitTree(pDynLoad->pMod);
4737	else
4738	rc = 0;
4739	if (rc == 0)
4740	{
4741	KW_LOG(("LoadLibraryExA(%s,,) -> %p [cached]\n", pszFilename, pDynLoad->hmod));
4742	return pDynLoad->hmod;
4743	}
4744	SetLastError(ERROR_DLL_INIT_FAILED);
4745	return NULL;
4746	}
4747
4748	/*
4749	* Allocate a dynload entry for the request.
4750	*/
4751	pDynLoad = (PKWDYNLOAD)kHlpAlloc(sizeof(*pDynLoad) + cchFilename + 1);
4752	if (pDynLoad)
4753	{
4754	pDynLoad->cchRequest = cchFilename;
4755	kHlpMemCopy(pDynLoad->szRequest, pszFilename, cchFilename + 1);
4756	}
4757	else
4758	{
4759	KW_LOG(("LoadLibraryExA: Out of memory!\n"));
4760	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4761	return NULL;
4762	}
4763
4764	/*
4765	* Deal with resource / data DLLs.
4766	*/
4767	if (fFlags & ( DONT_RESOLVE_DLL_REFERENCES
4768	\| LOAD_LIBRARY_AS_DATAFILE
4769	\| LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE
4770	\| LOAD_LIBRARY_AS_IMAGE_RESOURCE) )
4771	return kwSandbox_Kernel32_LoadLibraryExA_Resource(pDynLoad, fFlags);
4772
4773	/*
4774	* Special case: api-ms-win-core-synch-l1-2-0 and friends (32-bit yasm, built with VS2015).
4775	*/
4776	if ( strnicmp(pszFilename, TUPLE("api-ms-")) == 0
4777	&& kHlpIsFilenameOnly(pszFilename))
4778	return kwSandbox_Kernel32_LoadLibraryExA_VirtualApiModule(pDynLoad, fFlags);
4779
4780	/*
4781	* Normal library loading.
4782	* We start by being very lazy and reusing the code for resolving imports.
4783	*/
4784	pszSearchPath = kwSandboxDoGetEnvA(&g_Sandbox, "PATH", 4);
4785	if (!kHlpIsFilenameOnly(pszFilename))
4786	pMod = kwLdrModuleTryLoadDll(pszFilename, KWLOCATION_UNKNOWN, g_Sandbox.pTool->u.Sandboxed.pExe, pszSearchPath);
4787	else
4788	{
4789	rc = kwLdrModuleResolveAndLookup(pszFilename, g_Sandbox.pTool->u.Sandboxed.pExe, NULL /pImporter/, pszSearchPath, &pMod);
4790	if (rc != 0)
4791	pMod = NULL;
4792	}
4793	if (pMod && pMod != (PKWMODULE)~(KUPTR)0)
4794	{
4795	/* Enter it into the tool module table and dynamic link request cache. */
4796	kwToolAddModuleAndImports(g_Sandbox.pTool, pMod);
4797
4798	pDynLoad->pMod = pMod;
4799	pDynLoad->hmod = pMod->hOurMod;
4800
4801	pDynLoad->pNext = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead;
4802	g_Sandbox.pTool->u.Sandboxed.pDynLoadHead = pDynLoad;
4803
4804	/*
4805	* Make sure it's initialized (need to link it first since DllMain may
4806	* use loader APIs).
4807	*/
4808	rc = kwLdrModuleInitTree(pMod);
4809	if (rc == 0)
4810	{
4811	KW_LOG(("LoadLibraryExA(%s,,) -> %p\n", pszFilename, pDynLoad->hmod));
4812	return pDynLoad->hmod;
4813	}
4814
4815	SetLastError(ERROR_DLL_INIT_FAILED);
4816	}
4817	else
4818	{
4819	KWFS_TODO();
4820	kHlpFree(pDynLoad);
4821	SetLastError(pMod ? ERROR_BAD_EXE_FORMAT : ERROR_MOD_NOT_FOUND);
4822	}
4823	return NULL;
4824	}
4825
4826
4827	/** Kernel32 - LoadLibraryExA() for native overloads */
4828	static HMODULE WINAPI kwSandbox_Kernel32_Native_LoadLibraryExA(LPCSTR pszFilename, HANDLE hFile, DWORD fFlags)
4829	{
4830	char szPath[1024];
4831	KWLDR_LOG(("kwSandbox_Kernel32_Native_LoadLibraryExA(%s, %p, %#x)\n", pszFilename, hFile, fFlags));
4832
4833	/*
4834	* We may have to help resolved unqualified DLLs living in the executable directory.
4835	*/
4836	if (kHlpIsFilenameOnly(pszFilename))
4837	{
4838	KSIZE cchFilename = kHlpStrLen(pszFilename);
4839	KSIZE cchExePath = g_Sandbox.pTool->u.Sandboxed.pExe->offFilename;
4840	if (cchExePath + cchFilename + 1 <= sizeof(szPath))
4841	{
4842	kHlpMemCopy(szPath, g_Sandbox.pTool->u.Sandboxed.pExe->pszPath, cchExePath);
4843	kHlpMemCopy(&szPath[cchExePath], pszFilename, cchFilename + 1);
4844	if (kwFsPathExists(szPath))
4845	{
4846	KWLDR_LOG(("kwSandbox_Kernel32_Native_LoadLibraryExA: %s -> %s\n", pszFilename, szPath));
4847	pszFilename = szPath;
4848	}
4849	}
4850
4851	if (pszFilename != szPath)
4852	{
4853	KSIZE cchSuffix = 0;
4854	KBOOL fNeedSuffix = K_FALSE;
4855	const char *pszCur = kwSandboxDoGetEnvA(&g_Sandbox, "PATH", 4);
4856	while (*pszCur != '\0')
4857	{
4858	/* Find the end of the component */
4859	KSIZE cch = 0;
4860	while (pszCur[cch] != ';' && pszCur[cch] != '\0')
4861	cch++;
4862
4863	if ( cch > 0 /* wrong, but whatever */
4864	&& cch + 1 + cchFilename + cchSuffix < sizeof(szPath))
4865	{
4866	char *pszDst = kHlpMemPCopy(szPath, pszCur, cch);
4867	if ( szPath[cch - 1] != ':'
4868	&& szPath[cch - 1] != '/'
4869	&& szPath[cch - 1] != '\\')
4870	*pszDst++ = '\\';
4871	pszDst = kHlpMemPCopy(pszDst, pszFilename, cchFilename);
4872	if (fNeedSuffix)
4873	pszDst = kHlpMemPCopy(pszDst, ".dll", 4);
4874	*pszDst = '\0';
4875
4876	if (kwFsPathExists(szPath))
4877	{
4878	KWLDR_LOG(("kwSandbox_Kernel32_Native_LoadLibraryExA: %s -> %s\n", pszFilename, szPath));
4879	pszFilename = szPath;
4880	break;
4881	}
4882	}
4883
4884	/* Advance */
4885	pszCur += cch;
4886	while (*pszCur == ';')
4887	pszCur++;
4888	}
4889	}
4890	}
4891
4892	return LoadLibraryExA(pszFilename, hFile, fFlags);
4893	}
4894
4895
4896	/** Kernel32 - LoadLibraryExW() */
4897	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryExW(LPCWSTR pwszFilename, HANDLE hFile, DWORD fFlags)
4898	{
4899	char szTmp[4096];
4900	KSIZE cchTmp = kwUtf16ToStr(pwszFilename, szTmp, sizeof(szTmp));
4901	if (cchTmp < sizeof(szTmp))
4902	return kwSandbox_Kernel32_LoadLibraryExA(szTmp, hFile, fFlags);
4903
4904	KWFS_TODO();
4905	SetLastError(ERROR_FILENAME_EXCED_RANGE);
4906	return NULL;
4907	}
4908
4909	/** Kernel32 - LoadLibraryA() */
4910	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryA(LPCSTR pszFilename)
4911	{
4912	return kwSandbox_Kernel32_LoadLibraryExA(pszFilename, NULL /hFile/, 0 /fFlags/);
4913	}
4914
4915
4916	/** Kernel32 - LoadLibraryW() */
4917	static HMODULE WINAPI kwSandbox_Kernel32_LoadLibraryW(LPCWSTR pwszFilename)
4918	{
4919	char szTmp[4096];
4920	KSIZE cchTmp = kwUtf16ToStr(pwszFilename, szTmp, sizeof(szTmp));
4921	if (cchTmp < sizeof(szTmp))
4922	return kwSandbox_Kernel32_LoadLibraryExA(szTmp, NULL /hFile/, 0 /fFlags/);
4923	KWFS_TODO();
4924	SetLastError(ERROR_FILENAME_EXCED_RANGE);
4925	return NULL;
4926	}
4927
4928
4929	/** Kernel32 - FreeLibrary() */
4930	static BOOL WINAPI kwSandbox_Kernel32_FreeLibrary(HMODULE hmod)
4931	{
4932	/* Ignored, we like to keep everything loaded. */
4933	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4934	return TRUE;
4935	}
4936
4937
4938	/** Kernel32 - GetModuleHandleA() */
4939	static HMODULE WINAPI kwSandbox_Kernel32_GetModuleHandleA(LPCSTR pszModule)
4940	{
4941	KSIZE i;
4942	KSIZE cchModule;
4943	PKWDYNLOAD pDynLoad;
4944	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4945
4946	/*
4947	* The executable.
4948	*/
4949	if (pszModule == NULL)
4950	return (HMODULE)g_Sandbox.pTool->u.Sandboxed.pExe->hOurMod;
4951
4952	/*
4953	* Cache of system modules we've seen queried.
4954	*/
4955	cchModule = kHlpStrLen(pszModule);
4956	for (i = 0; i < K_ELEMENTS(g_aGetModuleHandleCache); i++)
4957	if ( g_aGetModuleHandleCache[i].cchName == cchModule
4958	&& stricmp(pszModule, g_aGetModuleHandleCache[i].pszName) == 0)
4959	{
4960	if (g_aGetModuleHandleCache[i].hmod != NULL)
4961	return g_aGetModuleHandleCache[i].hmod;
4962	return g_aGetModuleHandleCache[i].hmod = GetModuleHandleA(pszModule);
4963	}
4964
4965	/*
4966	* Modules we've dynamically loaded.
4967	*/
4968	for (pDynLoad = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead; pDynLoad; pDynLoad = pDynLoad->pNext)
4969	if ( pDynLoad->pMod
4970	&& ( stricmp(pDynLoad->pMod->pszPath, pszModule) == 0
4971	\|\| stricmp(&pDynLoad->pMod->pszPath[pDynLoad->pMod->offFilename], pszModule) == 0) )
4972	{
4973	if ( pDynLoad->pMod->fNative
4974	\|\| pDynLoad->pMod->u.Manual.enmState == KWMODSTATE_READY)
4975	{
4976	KW_LOG(("kwSandbox_Kernel32_GetModuleHandleA(%s,,) -> %p [dynload]\n", pszModule, pDynLoad->hmod));
4977	return pDynLoad->hmod;
4978	}
4979	SetLastError(ERROR_MOD_NOT_FOUND);
4980	return NULL;
4981	}
4982
4983	kwErrPrintf("pszModule=%s\n", pszModule);
4984	KWFS_TODO();
4985	SetLastError(ERROR_MOD_NOT_FOUND);
4986	return NULL;
4987	}
4988
4989
4990	/** Kernel32 - GetModuleHandleW() */
4991	static HMODULE WINAPI kwSandbox_Kernel32_GetModuleHandleW(LPCWSTR pwszModule)
4992	{
4993	KSIZE i;
4994	KSIZE cwcModule;
4995	PKWDYNLOAD pDynLoad;
4996	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
4997
4998	/*
4999	* The executable.
5000	*/
5001	if (pwszModule == NULL)
5002	return (HMODULE)g_Sandbox.pTool->u.Sandboxed.pExe->hOurMod;
5003
5004	/*
5005	* Cache of system modules we've seen queried.
5006	*/
5007	cwcModule = kwUtf16Len(pwszModule);
5008	for (i = 0; i < K_ELEMENTS(g_aGetModuleHandleCache); i++)
5009	if ( g_aGetModuleHandleCache[i].cwcName == cwcModule
5010	&& _wcsicmp(pwszModule, g_aGetModuleHandleCache[i].pwszName) == 0)
5011	{
5012	if (g_aGetModuleHandleCache[i].hmod != NULL)
5013	return g_aGetModuleHandleCache[i].hmod;
5014	return g_aGetModuleHandleCache[i].hmod = GetModuleHandleW(pwszModule);
5015	}
5016
5017	/*
5018	* Modules we've dynamically loaded.
5019	*/
5020	for (pDynLoad = g_Sandbox.pTool->u.Sandboxed.pDynLoadHead; pDynLoad; pDynLoad = pDynLoad->pNext)
5021	if ( pDynLoad->pMod
5022	&& ( _wcsicmp(pDynLoad->pMod->pwszPath, pwszModule) == 0
5023	\|\| _wcsicmp(&pDynLoad->pMod->pwszPath[pDynLoad->pMod->offFilename], pwszModule) == 0) ) /** @todo wrong offset */
5024	{
5025	if ( pDynLoad->pMod->fNative
5026	\|\| pDynLoad->pMod->u.Manual.enmState == KWMODSTATE_READY)
5027	{
5028	KW_LOG(("kwSandbox_Kernel32_GetModuleHandleW(%ls,,) -> %p [dynload]\n", pwszModule, pDynLoad->hmod));
5029	return pDynLoad->hmod;
5030	}
5031	SetLastError(ERROR_MOD_NOT_FOUND);
5032	return NULL;
5033	}
5034
5035	kwErrPrintf("pwszModule=%ls\n", pwszModule);
5036	KWFS_TODO();
5037	SetLastError(ERROR_MOD_NOT_FOUND);
5038	return NULL;
5039	}
5040
5041
5042	/** Used to debug dynamically resolved procedures. */
5043	static UINT WINAPI kwSandbox_BreakIntoDebugger(void pv1, void pv2, void pv3, void pv4)
5044	{
5045	#ifdef _MSC_VER
5046	__debugbreak();
5047	#else
5048	KWFS_TODO();
5049	#endif
5050	return -1;
5051	}
5052
5053
5054	#ifndef NDEBUG
5055	/*
5056	* This wraps up to three InvokeCompilerPassW functions and dumps their arguments to the log.
5057	*/
5058	# if K_ARCH == K_ARCH_X86_32
5059	static char g_szInvokeCompilePassW[] = "_InvokeCompilerPassW@16";
5060	# else
5061	static char g_szInvokeCompilePassW[] = "InvokeCompilerPassW";
5062	# endif
5063	typedef KIPTR __stdcall FNINVOKECOMPILERPASSW(int cArgs, wchar_t papwszArgs, KUPTR fFlags, void phCluiInstance);
5064	typedef FNINVOKECOMPILERPASSW *PFNINVOKECOMPILERPASSW;
5065	typedef struct KWCXINTERCEPTORENTRY
5066	{
5067	PFNINVOKECOMPILERPASSW pfnOrg;
5068	PKWMODULE pModule;
5069	PFNINVOKECOMPILERPASSW pfnWrap;
5070	} KWCXINTERCEPTORENTRY;
5071
5072	static KIPTR kwSandbox_Cx_InvokeCompilerPassW_Common(int cArgs, wchar_t papwszArgs, KUPTR fFlags, void phCluiInstance,
5073	KWCXINTERCEPTORENTRY *pEntry)
5074	{
5075	int i;
5076	KIPTR rcExit;
5077	KW_LOG(("%s!InvokeCompilerPassW(%d, %p, %#x, %p)\n",
5078	&pEntry->pModule->pszPath[pEntry->pModule->offFilename], cArgs, papwszArgs, fFlags, phCluiInstance));
5079	for (i = 0; i < cArgs; i++)
5080	KW_LOG((" papwszArgs[%u]='%ls'\n", i, papwszArgs[i]));
5081
5082	rcExit = pEntry->pfnOrg(cArgs, papwszArgs, fFlags, phCluiInstance);
5083
5084	KW_LOG(("%s!InvokeCompilerPassW returns %d\n", &pEntry->pModule->pszPath[pEntry->pModule->offFilename], rcExit));
5085	return rcExit;
5086	}
5087
5088	static FNINVOKECOMPILERPASSW kwSandbox_Cx_InvokeCompilerPassW_0;
5089	static FNINVOKECOMPILERPASSW kwSandbox_Cx_InvokeCompilerPassW_1;
5090	static FNINVOKECOMPILERPASSW kwSandbox_Cx_InvokeCompilerPassW_2;
5091
5092	static KWCXINTERCEPTORENTRY g_aCxInterceptorEntries[] =
5093	{
5094	{ NULL, NULL, kwSandbox_Cx_InvokeCompilerPassW_0 },
5095	{ NULL, NULL, kwSandbox_Cx_InvokeCompilerPassW_1 },
5096	{ NULL, NULL, kwSandbox_Cx_InvokeCompilerPassW_2 },
5097	};
5098
5099	static KIPTR __stdcall kwSandbox_Cx_InvokeCompilerPassW_0(int cArgs, wchar_t papwszArgs, KUPTR fFlags, void phCluiInstance)
5100	{
5101	return kwSandbox_Cx_InvokeCompilerPassW_Common(cArgs, papwszArgs, fFlags, phCluiInstance, &g_aCxInterceptorEntries[0]);
5102	}
5103
5104	static KIPTR __stdcall kwSandbox_Cx_InvokeCompilerPassW_1(int cArgs, wchar_t papwszArgs, KUPTR fFlags, void phCluiInstance)
5105	{
5106	return kwSandbox_Cx_InvokeCompilerPassW_Common(cArgs, papwszArgs, fFlags, phCluiInstance, &g_aCxInterceptorEntries[1]);
5107	}
5108
5109	static KIPTR __stdcall kwSandbox_Cx_InvokeCompilerPassW_2(int cArgs, wchar_t papwszArgs, KUPTR fFlags, void phCluiInstance)
5110	{
5111	return kwSandbox_Cx_InvokeCompilerPassW_Common(cArgs, papwszArgs, fFlags, phCluiInstance, &g_aCxInterceptorEntries[2]);
5112	}
5113
5114	#endif /* !NDEBUG */
5115
5116
5117	/** Kernel32 - GetProcAddress() */
5118	static FARPROC WINAPI kwSandbox_Kernel32_GetProcAddress(HMODULE hmod, LPCSTR pszProc)
5119	{
5120	KSIZE i;
5121	PKWMODULE pMod;
5122	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
5123
5124	/*
5125	* Try locate the module.
5126	*/
5127	pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
5128	if (pMod)
5129	{
5130	KLDRADDR uValue;
5131	int rc = kLdrModQuerySymbol(pMod->pLdrMod,
5132	pMod->fNative ? NULL : pMod->u.Manual.pvBits,
5133	pMod->fNative ? KLDRMOD_BASEADDRESS_MAP : (KUPTR)pMod->u.Manual.pbLoad,
5134	KU32_MAX /iSymbol/,
5135	pszProc,
5136	kHlpStrLen(pszProc),
5137	NULL /pszVersion/,
5138	NULL /pfnGetForwarder/, NULL /pvUser/,
5139	&uValue,
5140	NULL /pfKind/);
5141	if (rc == 0)
5142	{
5143	//static int s_cDbgGets = 0;
5144	KU32 cchProc = (KU32)kHlpStrLen(pszProc);
5145	KU32 i = g_cSandboxGetProcReplacements;
5146	while (i-- > 0)
5147	if ( g_aSandboxGetProcReplacements[i].cchFunction == cchProc
5148	&& kHlpMemComp(g_aSandboxGetProcReplacements[i].pszFunction, pszProc, cchProc) == 0)
5149	{
5150	if ( !g_aSandboxGetProcReplacements[i].pszModule
5151	\|\| kHlpStrICompAscii(g_aSandboxGetProcReplacements[i].pszModule, &pMod->pszPath[pMod->offFilename]) == 0)
5152	{
5153	if ( !g_aSandboxGetProcReplacements[i].fOnlyExe
5154	\|\| (KUPTR)_ReturnAddress() - (KUPTR)g_Sandbox.pTool->u.Sandboxed.pExe->hOurMod
5155	< g_Sandbox.pTool->u.Sandboxed.pExe->cbImage)
5156	{
5157	uValue = g_aSandboxGetProcReplacements[i].pfnReplacement;
5158	KW_LOG(("GetProcAddress(%s, %s) -> %p replaced\n", pMod->pszPath, pszProc, (KUPTR)uValue));
5159	}
5160	kwLdrModuleRelease(pMod);
5161	return (FARPROC)(KUPTR)uValue;
5162	}
5163	}
5164
5165	#ifndef NDEBUG
5166	/* Intercept the compiler pass method, dumping arguments. */
5167	if (kHlpStrComp(pszProc, g_szInvokeCompilePassW) == 0)
5168	{
5169	KU32 i;
5170	for (i = 0; i < K_ELEMENTS(g_aCxInterceptorEntries); i++)
5171	if ((KUPTR)g_aCxInterceptorEntries[i].pfnOrg == uValue)
5172	{
5173	uValue = (KUPTR)g_aCxInterceptorEntries[i].pfnWrap;
5174	KW_LOG(("GetProcAddress: intercepting InvokeCompilerPassW\n"));
5175	break;
5176	}
5177	if (i >= K_ELEMENTS(g_aCxInterceptorEntries))
5178	while (i-- > 0)
5179	if (g_aCxInterceptorEntries[i].pfnOrg == NULL)
5180	{
5181	g_aCxInterceptorEntries[i].pfnOrg = (PFNINVOKECOMPILERPASSW)(KUPTR)uValue;
5182	g_aCxInterceptorEntries[i].pModule = pMod;
5183	uValue = (KUPTR)g_aCxInterceptorEntries[i].pfnWrap;
5184	KW_LOG(("GetProcAddress: intercepting InvokeCompilerPassW (new)\n"));
5185	break;
5186	}
5187	}
5188	#endif
5189	KW_LOG(("GetProcAddress(%s, %s) -> %p\n", pMod->pszPath, pszProc, (KUPTR)uValue));
5190	kwLdrModuleRelease(pMod);
5191	//s_cDbgGets++;
5192	//if (s_cGets >= 3)
5193	// return (FARPROC)kwSandbox_BreakIntoDebugger;
5194	return (FARPROC)(KUPTR)uValue;
5195	}
5196
5197	KWFS_TODO();
5198	SetLastError(ERROR_PROC_NOT_FOUND);
5199	kwLdrModuleRelease(pMod);
5200	return NULL;
5201	}
5202
5203	/*
5204	* Hmm... could be a cached module-by-name.
5205	*/
5206	for (i = 0; i < K_ELEMENTS(g_aGetModuleHandleCache); i++)
5207	if (g_aGetModuleHandleCache[i].hmod == hmod)
5208	return GetProcAddress(hmod, pszProc);
5209
5210	KWFS_TODO();
5211	return GetProcAddress(hmod, pszProc);
5212	}
5213
5214
5215	/** Kernel32 - GetModuleFileNameA() */
5216	static DWORD WINAPI kwSandbox_Kernel32_GetModuleFileNameA(HMODULE hmod, LPSTR pszFilename, DWORD cbFilename)
5217	{
5218	PKWMODULE pMod;
5219	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
5220
5221	pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
5222	if (pMod != NULL)
5223	{
5224	DWORD cbRet = kwStrCopyStyle1(pMod->pszPath, pszFilename, cbFilename);
5225	kwLdrModuleRelease(pMod);
5226	return cbRet;
5227	}
5228	KWFS_TODO();
5229	return 0;
5230	}
5231
5232
5233	/** Kernel32 - GetModuleFileNameW() */
5234	static DWORD WINAPI kwSandbox_Kernel32_GetModuleFileNameW(HMODULE hmod, LPWSTR pwszFilename, DWORD cbFilename)
5235	{
5236	PKWMODULE pMod;
5237	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
5238
5239	pMod = kwToolLocateModuleByHandle(g_Sandbox.pTool, hmod);
5240	if (pMod)
5241	{
5242	DWORD cwcRet = kwUtf16CopyStyle1(pMod->pwszPath, pwszFilename, cbFilename);
5243	kwLdrModuleRelease(pMod);
5244	return cwcRet;
5245	}
5246
5247	KWFS_TODO();
5248	return 0;
5249	}
5250
5251
5252	/** NtDll - RtlPcToFileHeader
5253	* This is necessary for msvcr100.dll!CxxThrowException. */
5254	static PVOID WINAPI kwSandbox_ntdll_RtlPcToFileHeader(PVOID pvPC, PVOID *ppvImageBase)
5255	{
5256	PVOID pvRet;
5257
5258	/*
5259	* Do a binary lookup of the module table for the current tool.
5260	* This will give us a
5261	*/
5262	if (g_Sandbox.fRunning)
5263	{
5264	KUPTR const uPC = (KUPTR)pvPC;
5265	PKWMODULE *papMods = g_Sandbox.pTool->u.Sandboxed.papModules;
5266	KU32 iEnd = g_Sandbox.pTool->u.Sandboxed.cModules;
5267	KU32 i;
5268	if (iEnd)
5269	{
5270	KU32 iStart = 0;
5271	i = iEnd / 2;
5272	for (;;)
5273	{
5274	KUPTR const uHModThis = (KUPTR)papMods[i]->hOurMod;
5275	if (uPC < uHModThis)
5276	{
5277	iEnd = i;
5278	if (iStart < i)
5279	{ }
5280	else
5281	break;
5282	}
5283	else if (uPC != uHModThis)
5284	{
5285	iStart = ++i;
5286	if (i < iEnd)
5287	{ }
5288	else
5289	break;
5290	}
5291	else
5292	{
5293	/* This isn't supposed to happen. */
5294	break;
5295	}
5296
5297	i = iStart + (iEnd - iStart) / 2;
5298	}
5299
5300	/* For reasons of simplicity (= copy & paste), we end up with the
5301	module after the one we're interested in here. */
5302	i--;
5303	if (i < g_Sandbox.pTool->u.Sandboxed.cModules
5304	&& papMods[i]->pLdrMod)
5305	{
5306	KSIZE uRvaPC = uPC - (KUPTR)papMods[i]->hOurMod;
5307	if (uRvaPC < papMods[i]->cbImage)
5308	{
5309	*ppvImageBase = papMods[i]->hOurMod;
5310	pvRet = papMods[i]->hOurMod;
5311	KW_LOG(("RtlPcToFileHeader(PC=%p) -> %p, ppvImageBase=%p [our]\n", pvPC, pvRet, ppvImageBase));
5312	return pvRet;
5313	}
5314	}
5315	}
5316	else
5317	i = 0;
5318	}
5319
5320	/*
5321	* Call the regular API.
5322	*/
5323	pvRet = RtlPcToFileHeader(pvPC, ppvImageBase);
5324	KW_LOG(("RtlPcToFileHeader(PC=%p) -> %p, ppvImageBase=%p \n", pvPC, pvRet, ppvImageBase));
5325	return pvRet;
5326	}
5327
5328
5329	/*
5330	*
5331	* File access APIs (for speeding them up).
5332	* File access APIs (for speeding them up).
5333	* File access APIs (for speeding them up).
5334	*
5335	*/
5336
5337
5338	/**
5339	* Converts a lookup error to a windows error code.
5340	*
5341	* @returns The windows error code.
5342	* @param enmError The lookup error.
5343	*/
5344	static DWORD kwFsLookupErrorToWindowsError(KFSLOOKUPERROR enmError)
5345	{
5346	switch (enmError)
5347	{
5348	case KFSLOOKUPERROR_NOT_FOUND:
5349	case KFSLOOKUPERROR_NOT_DIR:
5350	return ERROR_FILE_NOT_FOUND;
5351
5352	case KFSLOOKUPERROR_PATH_COMP_NOT_FOUND:
5353	case KFSLOOKUPERROR_PATH_COMP_NOT_DIR:
5354	return ERROR_PATH_NOT_FOUND;
5355
5356	case KFSLOOKUPERROR_PATH_TOO_LONG:
5357	return ERROR_FILENAME_EXCED_RANGE;
5358
5359	case KFSLOOKUPERROR_OUT_OF_MEMORY:
5360	return ERROR_NOT_ENOUGH_MEMORY;
5361
5362	default:
5363	return ERROR_PATH_NOT_FOUND;
5364	}
5365	}
5366
5367	#ifdef WITH_TEMP_MEMORY_FILES
5368
5369	/**
5370	* Checks for a cl.exe temporary file.
5371	*
5372	* There are quite a bunch of these. They seems to be passing data between the
5373	* first and second compiler pass. Since they're on disk, they get subjected to
5374	* AV software screening and normal file consistency rules. So, not necessarily
5375	* a very efficient way of handling reasonably small amounts of data.
5376	*
5377	* We make the files live in virtual memory by intercepting their opening,
5378	* writing, reading, closing , mapping, unmapping, and maybe some more stuff.
5379	*
5380	* @returns K_TRUE / K_FALSE
5381	* @param pwszFilename The file name being accessed.
5382	*/
5383	static KBOOL kwFsIsClTempFileW(const wchar_t *pwszFilename)
5384	{
5385	wchar_t const *pwszName = kwPathGetFilenameW(pwszFilename);
5386	if (pwszName)
5387	{
5388	/* The name starts with _CL_... */
5389	if ( pwszName[0] == '_'
5390	&& pwszName[1] == 'C'
5391	&& pwszName[2] == 'L'
5392	&& pwszName[3] == '_' )
5393	{
5394	/* ... followed by 8 xdigits and ends with a two letter file type. Simplify
5395	this check by just checking that it's alpha numerical ascii from here on. */
5396	wchar_t wc;
5397	pwszName += 4;
5398	while ((wc = *pwszName++) != '\0')
5399	{
5400	if (wc < 127 && iswalnum(wc))
5401	{ /* likely */ }
5402	else
5403	return K_FALSE;
5404	}
5405	return K_TRUE;
5406	}
5407	}
5408	return K_FALSE;
5409	}
5410
5411
5412	/**
5413	* Creates a handle to a temporary file.
5414	*
5415	* @returns The handle on success.
5416	* INVALID_HANDLE_VALUE and SetLastError on failure.
5417	* @param pTempFile The temporary file.
5418	* @param dwDesiredAccess The desired access to the handle.
5419	* @param fMapping Whether this is a mapping (K_TRUE) or file
5420	* (K_FALSE) handle type.
5421	*/
5422	static HANDLE kwFsTempFileCreateHandle(PKWFSTEMPFILE pTempFile, DWORD dwDesiredAccess, KBOOL fMapping)
5423	{
5424	/*
5425	* Create a handle to the temporary file.
5426	*/
5427	HANDLE hFile = INVALID_HANDLE_VALUE;
5428	HANDLE hProcSelf = GetCurrentProcess();
5429	if (DuplicateHandle(hProcSelf, hProcSelf,
5430	hProcSelf, &hFile,
5431	SYNCHRONIZE, FALSE,
5432	0 /dwOptions/))
5433	{
5434	PKWHANDLE pHandle = (PKWHANDLE)kHlpAlloc(sizeof(*pHandle));
5435	if (pHandle)
5436	{
5437	pHandle->enmType = !fMapping ? KWHANDLETYPE_TEMP_FILE : KWHANDLETYPE_TEMP_FILE_MAPPING;
5438	pHandle->cRefs = 1;
5439	pHandle->offFile = 0;
5440	pHandle->hHandle = hFile;
5441	pHandle->dwDesiredAccess = dwDesiredAccess;
5442	pHandle->u.pTempFile = pTempFile;
5443	if (kwSandboxHandleTableEnter(&g_Sandbox, pHandle, hFile))
5444	{
5445	pTempFile->cActiveHandles++;
5446	kHlpAssert(pTempFile->cActiveHandles >= 1);
5447	kHlpAssert(pTempFile->cActiveHandles <= 2);
5448	KWFS_LOG(("kwFsTempFileCreateHandle: Temporary file '%ls' -> %p\n", pTempFile->pwszPath, hFile));
5449	return hFile;
5450	}
5451
5452	kHlpFree(pHandle);
5453	}
5454	else
5455	KWFS_LOG(("kwFsTempFileCreateHandle: Out of memory!\n"));
5456	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5457	}
5458	else
5459	KWFS_LOG(("kwFsTempFileCreateHandle: DuplicateHandle failed: err=%u\n", GetLastError()));
5460	return INVALID_HANDLE_VALUE;
5461	}
5462
5463
5464	static HANDLE kwFsTempFileCreateW(const wchar_t *pwszFilename, DWORD dwDesiredAccess, DWORD dwCreationDisposition)
5465	{
5466	HANDLE hFile;
5467	DWORD dwErr;
5468
5469	/*
5470	* Check if we've got an existing temp file.
5471	* ASSUME exact same path for now.
5472	*/
5473	KSIZE const cwcFilename = kwUtf16Len(pwszFilename);
5474	PKWFSTEMPFILE pTempFile;
5475	for (pTempFile = g_Sandbox.pTempFileHead; pTempFile != NULL; pTempFile = pTempFile->pNext)
5476	{
5477	/* Since the last two chars are usually the only difference, we check them manually before calling memcmp. */
5478	if ( pTempFile->cwcPath == cwcFilename
5479	&& pTempFile->pwszPath[cwcFilename - 1] == pwszFilename[cwcFilename - 1]
5480	&& pTempFile->pwszPath[cwcFilename - 2] == pwszFilename[cwcFilename - 2]
5481	&& kHlpMemComp(pTempFile->pwszPath, pwszFilename, cwcFilename) == 0)
5482	break;
5483	}
5484
5485	/*
5486	* Create a new temporary file instance if not found.
5487	*/
5488	if (pTempFile == NULL)
5489	{
5490	KSIZE cbFilename;
5491
5492	switch (dwCreationDisposition)
5493	{
5494	case CREATE_ALWAYS:
5495	case OPEN_ALWAYS:
5496	dwErr = NO_ERROR;
5497	break;
5498
5499	case CREATE_NEW:
5500	kHlpAssertFailed();
5501	SetLastError(ERROR_ALREADY_EXISTS);
5502	return INVALID_HANDLE_VALUE;
5503
5504	case OPEN_EXISTING:
5505	case TRUNCATE_EXISTING:
5506	kHlpAssertFailed();
5507	SetLastError(ERROR_FILE_NOT_FOUND);
5508	return INVALID_HANDLE_VALUE;
5509
5510	default:
5511	kHlpAssertFailed();
5512	SetLastError(ERROR_INVALID_PARAMETER);
5513	return INVALID_HANDLE_VALUE;
5514	}
5515
5516	cbFilename = (cwcFilename + 1) * sizeof(wchar_t);
5517	pTempFile = (PKWFSTEMPFILE)kHlpAlloc(sizeof(*pTempFile) + cbFilename);
5518	if (pTempFile)
5519	{
5520	pTempFile->cwcPath = (KU16)cwcFilename;
5521	pTempFile->cbFile = 0;
5522	pTempFile->cbFileAllocated = 0;
5523	pTempFile->cActiveHandles = 0;
5524	pTempFile->cMappings = 0;
5525	pTempFile->cSegs = 0;
5526	pTempFile->paSegs = NULL;
5527	pTempFile->pwszPath = (wchar_t const *)kHlpMemCopy(pTempFile + 1, pwszFilename, cbFilename);
5528
5529	pTempFile->pNext = g_Sandbox.pTempFileHead;
5530	g_Sandbox.pTempFileHead = pTempFile;
5531	KWFS_LOG(("kwFsTempFileCreateW: Created new temporary file '%ls'\n", pwszFilename));
5532	}
5533	else
5534	{
5535	KWFS_LOG(("kwFsTempFileCreateW: Out of memory!\n"));
5536	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5537	return INVALID_HANDLE_VALUE;
5538	}
5539	}
5540	else
5541	{
5542	switch (dwCreationDisposition)
5543	{
5544	case OPEN_EXISTING:
5545	dwErr = NO_ERROR;
5546	break;
5547	case OPEN_ALWAYS:
5548	dwErr = ERROR_ALREADY_EXISTS ;
5549	break;
5550
5551	case TRUNCATE_EXISTING:
5552	case CREATE_ALWAYS:
5553	kHlpAssertFailed();
5554	pTempFile->cbFile = 0;
5555	dwErr = ERROR_ALREADY_EXISTS;
5556	break;
5557
5558	case CREATE_NEW:
5559	kHlpAssertFailed();
5560	SetLastError(ERROR_FILE_EXISTS);
5561	return INVALID_HANDLE_VALUE;
5562
5563	default:
5564	kHlpAssertFailed();
5565	SetLastError(ERROR_INVALID_PARAMETER);
5566	return INVALID_HANDLE_VALUE;
5567	}
5568	}
5569
5570	/*
5571	* Create a handle to the temporary file.
5572	*/
5573	hFile = kwFsTempFileCreateHandle(pTempFile, dwDesiredAccess, K_FALSE /fMapping/);
5574	if (hFile != INVALID_HANDLE_VALUE)
5575	SetLastError(dwErr);
5576	return hFile;
5577	}
5578
5579	#endif /* WITH_TEMP_MEMORY_FILES */
5580
5581	/**
5582	* Worker for kwFsIsCacheableExtensionA and kwFsIsCacheableExtensionW
5583	*
5584	* @returns K_TRUE if cacheable, K_FALSE if not.
5585	* @param wcFirst The first extension character.
5586	* @param wcSecond The second extension character.
5587	* @param wcThird The third extension character.
5588	* @param fAttrQuery Set if it's for an attribute query, clear if for
5589	* file creation.
5590	*/
5591	static KBOOL kwFsIsCacheableExtensionCommon(wchar_t wcFirst, wchar_t wcSecond, wchar_t wcThird, KBOOL fAttrQuery)
5592	{
5593	/* C++ header without an extension or a directory. */
5594	if (wcFirst == '\0')
5595	{
5596	/** @todo exclude temporary files... */
5597	return K_TRUE;
5598	}
5599
5600	/* C Header: .h */
5601	if (wcFirst == 'h' \|\| wcFirst == 'H')
5602	{
5603	if (wcSecond == '\0')
5604	return K_TRUE;
5605
5606	/* C++ Header: .hpp, .hxx */
5607	if ( (wcSecond == 'p' \|\| wcSecond == 'P')
5608	&& (wcThird == 'p' \|\| wcThird == 'P'))
5609	return K_TRUE;
5610	if ( (wcSecond == 'x' \|\| wcSecond == 'X')
5611	&& (wcThird == 'x' \|\| wcThird == 'X'))
5612	return K_TRUE;
5613	}
5614	/* Misc starting with i. */
5615	else if (wcFirst == 'i' \|\| wcFirst == 'I')
5616	{
5617	if (wcSecond != '\0')
5618	{
5619	if (wcSecond == 'n' \|\| wcSecond == 'N')
5620	{
5621	/* C++ inline header: .inl */
5622	if (wcThird == 'l' \|\| wcThird == 'L')
5623	return K_TRUE;
5624
5625	/* Assembly include file: .inc */
5626	if (wcThird == 'c' \|\| wcThird == 'C')
5627	return K_TRUE;
5628	}
5629	}
5630	}
5631	/* Assembly header: .mac */
5632	else if (wcFirst == 'm' \|\| wcFirst == 'M')
5633	{
5634	if (wcSecond == 'a' \|\| wcSecond == 'A')
5635	{
5636	if (wcThird == 'c' \|\| wcThird == 'C')
5637	return K_TRUE;
5638	}
5639	}
5640	#ifdef WITH_PCH_CACHING
5641	/* Precompiled header: .pch */
5642	else if (wcFirst == 'p' \|\| wcFirst == 'P')
5643	{
5644	if (wcSecond == 'c' \|\| wcSecond == 'C')
5645	{
5646	if (wcThird == 'h' \|\| wcThird == 'H')
5647	return !g_Sandbox.fNoPchCaching;
5648	}
5649	}
5650	#endif
5651	#if 0 /* Experimental - need to flush these afterwards as they're highly unlikely to be used after the link is done. */
5652	/* Linker - Object file: .obj */
5653	if ((wcFirst == 'o' \|\| wcFirst == 'O') && g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
5654	{
5655	if (wcSecond == 'b' \|\| wcSecond == 'B')
5656	{
5657	if (wcThird == 'j' \|\| wcThird == 'J')
5658	return K_TRUE;
5659	}
5660	}
5661	#endif
5662	else if (fAttrQuery)
5663	{
5664	/* Dynamic link library: .dll */
5665	if (wcFirst == 'd' \|\| wcFirst == 'D')
5666	{
5667	if (wcSecond == 'l' \|\| wcSecond == 'L')
5668	{
5669	if (wcThird == 'l' \|\| wcThird == 'L')
5670	return K_TRUE;
5671	}
5672	}
5673	/* Executable file: .exe */
5674	else if (wcFirst == 'e' \|\| wcFirst == 'E')
5675	{
5676	if (wcSecond == 'x' \|\| wcSecond == 'X')
5677	{
5678	if (wcThird == 'e' \|\| wcThird == 'E')
5679	return K_TRUE;
5680	}
5681	}
5682	/* Response file: .rsp */
5683	else if (wcFirst == 'r' \|\| wcFirst == 'R')
5684	{
5685	if (wcSecond == 's' \|\| wcSecond == 'S')
5686	{
5687	if (wcThird == 'p' \|\| wcThird == 'P')
5688	return !g_Sandbox.fNoPchCaching;
5689	}
5690	}
5691	/* Linker: */
5692	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_LINK)
5693	{
5694	/* Object file: .obj */
5695	if (wcFirst == 'o' \|\| wcFirst == 'O')
5696	{
5697	if (wcSecond == 'b' \|\| wcSecond == 'B')
5698	{
5699	if (wcThird == 'j' \|\| wcThird == 'J')
5700	return K_TRUE;
5701	}
5702	}
5703	/* Library file: .lib */
5704	else if (wcFirst == 'l' \|\| wcFirst == 'L')
5705	{
5706	if (wcSecond == 'i' \|\| wcSecond == 'I')
5707	{
5708	if (wcThird == 'b' \|\| wcThird == 'B')
5709	return K_TRUE;
5710	}
5711	}
5712	/* Linker definition file: .def */
5713	else if (wcFirst == 'd' \|\| wcFirst == 'D')
5714	{
5715	if (wcSecond == 'e' \|\| wcSecond == 'E')
5716	{
5717	if (wcThird == 'f' \|\| wcThird == 'F')
5718	return K_TRUE;
5719	}
5720	}
5721	}
5722	}
5723
5724	return K_FALSE;
5725	}
5726
5727
5728	/**
5729	* Checks if the file extension indicates that the file/dir is something we
5730	* ought to cache.
5731	*
5732	* @returns K_TRUE if cachable, K_FALSE if not.
5733	* @param pszExt The kHlpGetExt result.
5734	* @param fAttrQuery Set if it's for an attribute query, clear if for
5735	* file creation.
5736	*/
5737	static KBOOL kwFsIsCacheableExtensionA(const char *pszExt, KBOOL fAttrQuery)
5738	{
5739	wchar_t const wcFirst = *pszExt;
5740	if (wcFirst)
5741	{
5742	wchar_t const wcSecond = pszExt[1];
5743	if (wcSecond)
5744	{
5745	wchar_t const wcThird = pszExt[2];
5746	if (pszExt[3] == '\0')
5747	return kwFsIsCacheableExtensionCommon(wcFirst, wcSecond, wcThird, fAttrQuery);
5748	return K_FALSE;
5749	}
5750	return kwFsIsCacheableExtensionCommon(wcFirst, 0, 0, fAttrQuery);
5751	}
5752	return kwFsIsCacheableExtensionCommon(0, 0, 0, fAttrQuery);
5753	}
5754
5755
5756	/**
5757	* Checks if the extension of the given UTF-16 path indicates that the file/dir
5758	* should be cached.
5759	*
5760	* @returns K_TRUE if cachable, K_FALSE if not.
5761	* @param pwszPath The UTF-16 path to examine.
5762	* @param fAttrQuery Set if it's for an attribute query, clear if for
5763	* file creation.
5764	*/
5765	static KBOOL kwFsIsCacheablePathExtensionW(const wchar_t *pwszPath, KBOOL fAttrQuery)
5766	{
5767	KSIZE cwcExt;
5768	wchar_t const *pwszExt = kwFsPathGetExtW(pwszPath, &cwcExt);
5769	switch (cwcExt)
5770	{
5771	case 3: return kwFsIsCacheableExtensionCommon(pwszExt[0], pwszExt[1], pwszExt[2], fAttrQuery);
5772	case 2: return kwFsIsCacheableExtensionCommon(pwszExt[0], pwszExt[1], 0, fAttrQuery);
5773	case 1: return kwFsIsCacheableExtensionCommon(pwszExt[0], 0, 0, fAttrQuery);
5774	case 0: return kwFsIsCacheableExtensionCommon(0, 0, 0, fAttrQuery);
5775	}
5776	return K_FALSE;
5777	}
5778
5779
5780
5781	/**
5782	* Creates a new
5783	*
5784	* @returns
5785	* @param pFsObj .
5786	* @param pwszFilename .
5787	*/
5788	static PKFSWCACHEDFILE kwFsObjCacheNewFile(PKFSOBJ pFsObj)
5789	{
5790	HANDLE hFile;
5791	MY_IO_STATUS_BLOCK Ios;
5792	MY_OBJECT_ATTRIBUTES ObjAttr;
5793	MY_UNICODE_STRING UniStr;
5794	MY_NTSTATUS rcNt;
5795	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
5796
5797	/*
5798	* Open the file relative to the parent directory.
5799	*/
5800	kHlpAssert(pFsObj->bObjType == KFSOBJ_TYPE_FILE);
5801	kHlpAssert(pFsObj->pParent);
5802	kHlpAssertReturn(pFsObj->pParent->hDir != INVALID_HANDLE_VALUE, NULL);
5803
5804	Ios.Information = -1;
5805	Ios.u.Status = -1;
5806
5807	UniStr.Buffer = (wchar_t *)pFsObj->pwszName;
5808	UniStr.Length = (USHORT)(pFsObj->cwcName * sizeof(wchar_t));
5809	UniStr.MaximumLength = UniStr.Length + sizeof(wchar_t);
5810
5811	MyInitializeObjectAttributes(&ObjAttr, &UniStr, OBJ_CASE_INSENSITIVE, pFsObj->pParent->hDir, NULL /pSecAttr/);
5812
5813	rcNt = g_pfnNtCreateFile(&hFile,
5814	GENERIC_READ \| SYNCHRONIZE,
5815	&ObjAttr,
5816	&Ios,
5817	NULL, /cbFileInitialAlloc /
5818	FILE_ATTRIBUTE_NORMAL,
5819	FILE_SHARE_READ,
5820	FILE_OPEN,
5821	FILE_NON_DIRECTORY_FILE \| FILE_SYNCHRONOUS_IO_NONALERT,
5822	NULL, /pEaBuffer/
5823	0); /cbEaBuffer/
5824	if (MY_NT_SUCCESS(rcNt))
5825	{
5826	/*
5827	* Read the whole file into memory.
5828	*/
5829	LARGE_INTEGER cbFile;
5830	if (GetFileSizeEx(hFile, &cbFile))
5831	{
5832	if ( cbFile.QuadPart >= 0
5833	#ifdef WITH_PCH_CACHING
5834	&& ( cbFile.QuadPart < 1610241024
5835	\|\| ( cbFile.QuadPart < 9610241024
5836	&& pFsObj->cchName > 4
5837	&& !g_Sandbox.fNoPchCaching
5838	&& kHlpStrICompAscii(&pFsObj->pszName[pFsObj->cchName - 4], ".pch") == 0) )
5839	#endif
5840	)
5841	{
5842	KU32 cbCache = (KU32)cbFile.QuadPart;
5843	HANDLE hMapping = CreateFileMappingW(hFile, NULL /pSecAttrs/, PAGE_READONLY,
5844	0 /cbMaxLow/, 0 /cbMaxHigh/, NULL /pwszName/);
5845	if (hMapping != NULL)
5846	{
5847	KU8 pbCache = (KU8 )MapViewOfFile(hMapping, FILE_MAP_READ, 0 /offFileHigh/, 0 /offFileLow/, cbCache);
5848	if (pbCache)
5849	{
5850	/*
5851	* Create the cached file object.
5852	*/
5853	PKFSWCACHEDFILE pCachedFile;
5854	KU32 cbPath = pFsObj->cchParent + pFsObj->cchName + 2;
5855	pCachedFile = (PKFSWCACHEDFILE)kFsCacheObjAddUserData(g_pFsCache, pFsObj, KW_DATA_KEY_CACHED_FILE,
5856	sizeof(*pCachedFile) + cbPath);
5857	if (pCachedFile)
5858	{
5859	pCachedFile->hCached = hFile;
5860	pCachedFile->hSection = hMapping;
5861	pCachedFile->cbCached = cbCache;
5862	pCachedFile->pbCached = pbCache;
5863	pCachedFile->pFsObj = pFsObj;
5864	kFsCacheObjGetFullPathA(pFsObj, pCachedFile->szPath, cbPath, '/');
5865	kFsCacheObjRetain(pFsObj);
5866
5867	g_cReadCachedFiles++;
5868	g_cbReadCachedFiles += cbCache;
5869
5870	KWFS_LOG(("Cached '%s': %p LB %#x, hCached=%p\n", pCachedFile->szPath, pbCache, cbCache, hFile));
5871	return pCachedFile;
5872	}
5873
5874	KWFS_LOG(("Failed to allocate KFSWCACHEDFILE structure!\n"));
5875	}
5876	else
5877	KWFS_LOG(("Failed to cache file: MapViewOfFile failed: %u\n", GetLastError()));
5878	CloseHandle(hMapping);
5879	}
5880	else
5881	KWFS_LOG(("Failed to cache file: CreateFileMappingW failed: %u\n", GetLastError()));
5882	}
5883	else
5884	KWFS_LOG(("File to big to cache! %#llx\n", cbFile.QuadPart));
5885	}
5886	else
5887	KWFS_LOG(("File to get file size! err=%u\n", GetLastError()));
5888	g_pfnNtClose(hFile);
5889	}
5890	else
5891	KWFS_LOG(("Error opening '%ls' for caching: %#x\n", pFsObj->pwszName, rcNt));
5892	return NULL;
5893	}
5894
5895
5896	/**
5897	* Kernel32 - Common code for kwFsObjCacheCreateFile and CreateFileMappingW/A.
5898	*/
5899	static KBOOL kwFsObjCacheCreateFileHandle(PKFSWCACHEDFILE pCachedFile, DWORD dwDesiredAccess, BOOL fInheritHandle,
5900	KBOOL fIsFileHandle, HANDLE *phFile)
5901	{
5902	HANDLE hProcSelf = GetCurrentProcess();
5903	if (DuplicateHandle(hProcSelf, fIsFileHandle ? pCachedFile->hCached : pCachedFile->hSection,
5904	hProcSelf, phFile,
5905	dwDesiredAccess, fInheritHandle,
5906	0 /dwOptions/))
5907	{
5908	/*
5909	* Create handle table entry for the duplicate handle.
5910	*/
5911	PKWHANDLE pHandle = (PKWHANDLE)kHlpAlloc(sizeof(*pHandle));
5912	if (pHandle)
5913	{
5914	pHandle->enmType = fIsFileHandle ? KWHANDLETYPE_FSOBJ_READ_CACHE : KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING;
5915	pHandle->cRefs = 1;
5916	pHandle->offFile = 0;
5917	pHandle->hHandle = *phFile;
5918	pHandle->dwDesiredAccess = dwDesiredAccess;
5919	pHandle->u.pCachedFile = pCachedFile;
5920	if (kwSandboxHandleTableEnter(&g_Sandbox, pHandle, pHandle->hHandle))
5921	return K_TRUE;
5922
5923	kHlpFree(pHandle);
5924	}
5925	else
5926	KWFS_LOG(("Out of memory for handle!\n"));
5927
5928	CloseHandle(*phFile);
5929	*phFile = INVALID_HANDLE_VALUE;
5930	}
5931	else
5932	KWFS_LOG(("DuplicateHandle failed! err=%u\n", GetLastError()));
5933	return K_FALSE;
5934	}
5935
5936
5937	/**
5938	* Kernel32 - Common code for CreateFileW and CreateFileA.
5939	*/
5940	static KBOOL kwFsObjCacheCreateFile(PKFSOBJ pFsObj, DWORD dwDesiredAccess, BOOL fInheritHandle, HANDLE *phFile)
5941	{
5942	*phFile = INVALID_HANDLE_VALUE;
5943
5944	/*
5945	* At the moment we only handle existing files.
5946	*/
5947	if (pFsObj->bObjType == KFSOBJ_TYPE_FILE)
5948	{
5949	PKFSWCACHEDFILE pCachedFile = (PKFSWCACHEDFILE)kFsCacheObjGetUserData(g_pFsCache, pFsObj, KW_DATA_KEY_CACHED_FILE);
5950	kHlpAssert(pFsObj->fHaveStats);
5951	if ( pCachedFile != NULL
5952	\|\| (pCachedFile = kwFsObjCacheNewFile(pFsObj)) != NULL)
5953	{
5954	if (kwFsObjCacheCreateFileHandle(pCachedFile, dwDesiredAccess, fInheritHandle, K_TRUE /fIsFileHandle/, phFile))
5955	return K_TRUE;
5956	}
5957	}
5958	/** @todo Deal with non-existing files if it becomes necessary (it's not for VS2010). */
5959
5960	/* Do fallback, please. */
5961	return K_FALSE;
5962	}
5963
5964
5965	/** Kernel32 - CreateFileA */
5966	static HANDLE WINAPI kwSandbox_Kernel32_CreateFileA(LPCSTR pszFilename, DWORD dwDesiredAccess, DWORD dwShareMode,
5967	LPSECURITY_ATTRIBUTES pSecAttrs, DWORD dwCreationDisposition,
5968	DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
5969	{
5970	HANDLE hFile;
5971
5972	/*
5973	* Check for include files and similar that we do read-only caching of.
5974	*/
5975	if (dwCreationDisposition == FILE_OPEN_IF)
5976	{
5977	if ( dwDesiredAccess == GENERIC_READ
5978	\|\| dwDesiredAccess == FILE_GENERIC_READ)
5979	{
5980	if (dwShareMode & FILE_SHARE_READ)
5981	{
5982	if ( !pSecAttrs
5983	\|\| ( pSecAttrs->nLength == sizeof(*pSecAttrs)
5984	&& pSecAttrs->lpSecurityDescriptor == NULL ) )
5985	{
5986	const char *pszExt = kHlpGetExt(pszFilename);
5987	if (kwFsIsCacheableExtensionA(pszExt, K_FALSE /fAttrQuery/))
5988	{
5989	KFSLOOKUPERROR enmError;
5990	PKFSOBJ pFsObj;
5991	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
5992
5993	pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
5994	if (pFsObj)
5995	{
5996	KBOOL fRc = kwFsObjCacheCreateFile(pFsObj, dwDesiredAccess, pSecAttrs && pSecAttrs->bInheritHandle,
5997	&hFile);
5998	kFsCacheObjRelease(g_pFsCache, pFsObj);
5999	if (fRc)
6000	{
6001	KWFS_LOG(("CreateFileA(%s) -> %p [cached]\n", pszFilename, hFile));
6002	return hFile;
6003	}
6004	}
6005	/* These are for nasm and yasm header searching. Cache will already
6006	have checked the directories for the file, no need to call
6007	CreateFile to do it again. */
6008	else if (enmError == KFSLOOKUPERROR_NOT_FOUND)
6009	{
6010	KWFS_LOG(("CreateFileA(%s) -> INVALID_HANDLE_VALUE, ERROR_FILE_NOT_FOUND\n", pszFilename));
6011	return INVALID_HANDLE_VALUE;
6012	}
6013	else if ( enmError == KFSLOOKUPERROR_PATH_COMP_NOT_FOUND
6014	\|\| enmError == KFSLOOKUPERROR_PATH_COMP_NOT_DIR)
6015	{
6016	KWFS_LOG(("CreateFileA(%s) -> INVALID_HANDLE_VALUE, ERROR_PATH_NOT_FOUND\n", pszFilename));
6017	return INVALID_HANDLE_VALUE;
6018	}
6019
6020	/* fallback */
6021	hFile = CreateFileA(pszFilename, dwDesiredAccess, dwShareMode, pSecAttrs,
6022	dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
6023	KWFS_LOG(("CreateFileA(%s) -> %p (err=%u) [fallback]\n", pszFilename, hFile, GetLastError()));
6024	return hFile;
6025	}
6026	}
6027	}
6028	}
6029	}
6030
6031	/*
6032	* Okay, normal.
6033	*/
6034	hFile = CreateFileA(pszFilename, dwDesiredAccess, dwShareMode, pSecAttrs,
6035	dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
6036	if (hFile != INVALID_HANDLE_VALUE)
6037	{
6038	kHlpAssert( KW_HANDLE_TO_INDEX(hFile) >= g_Sandbox.cHandles
6039	\|\| g_Sandbox.papHandles[KW_HANDLE_TO_INDEX(hFile)] == NULL);
6040	}
6041	KWFS_LOG(("CreateFileA(%s) -> %p\n", pszFilename, hFile));
6042	return hFile;
6043	}
6044
6045
6046	/** Kernel32 - CreateFileW */
6047	static HANDLE WINAPI kwSandbox_Kernel32_CreateFileW(LPCWSTR pwszFilename, DWORD dwDesiredAccess, DWORD dwShareMode,
6048	LPSECURITY_ATTRIBUTES pSecAttrs, DWORD dwCreationDisposition,
6049	DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
6050	{
6051	HANDLE hFile;
6052
6053	#ifdef WITH_TEMP_MEMORY_FILES
6054	/*
6055	* Check for temporary files (cl.exe only).
6056	*/
6057	if ( g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL
6058	&& !(dwFlagsAndAttributes & (FILE_ATTRIBUTE_DIRECTORY \| FILE_ATTRIBUTE_DEVICE \| FILE_FLAG_BACKUP_SEMANTICS))
6059	&& !(dwDesiredAccess & (GENERIC_EXECUTE \| FILE_EXECUTE))
6060	&& kwFsIsClTempFileW(pwszFilename))
6061	{
6062	hFile = kwFsTempFileCreateW(pwszFilename, dwDesiredAccess, dwCreationDisposition);
6063	KWFS_LOG(("CreateFileW(%ls) -> %p [temp]\n", pwszFilename, hFile));
6064	return hFile;
6065	}
6066	#endif
6067
6068	/*
6069	* Check for include files and similar that we do read-only caching of.
6070	*/
6071	if (dwCreationDisposition == FILE_OPEN_IF)
6072	{
6073	if ( dwDesiredAccess == GENERIC_READ
6074	\|\| dwDesiredAccess == FILE_GENERIC_READ)
6075	{
6076	if (dwShareMode & FILE_SHARE_READ)
6077	{
6078	if ( !pSecAttrs
6079	\|\| ( pSecAttrs->nLength == sizeof(*pSecAttrs)
6080	&& pSecAttrs->lpSecurityDescriptor == NULL ) )
6081	{
6082	if (kwFsIsCacheablePathExtensionW(pwszFilename, K_FALSE /fAttrQuery/))
6083	{
6084	KFSLOOKUPERROR enmError;
6085	PKFSOBJ pFsObj;
6086	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6087
6088	pFsObj = kFsCacheLookupNoMissingW(g_pFsCache, pwszFilename, &enmError);
6089	if (pFsObj)
6090	{
6091	KBOOL fRc = kwFsObjCacheCreateFile(pFsObj, dwDesiredAccess, pSecAttrs && pSecAttrs->bInheritHandle,
6092	&hFile);
6093	kFsCacheObjRelease(g_pFsCache, pFsObj);
6094	if (fRc)
6095	{
6096	KWFS_LOG(("CreateFileW(%ls) -> %p [cached]\n", pwszFilename, hFile));
6097	return hFile;
6098	}
6099	}
6100	/* These are for nasm and yasm style header searching. Cache will
6101	already have checked the directories for the file, no need to call
6102	CreateFile to do it again. */
6103	else if (enmError == KFSLOOKUPERROR_NOT_FOUND)
6104	{
6105	KWFS_LOG(("CreateFileW(%ls) -> INVALID_HANDLE_VALUE, ERROR_FILE_NOT_FOUND\n", pwszFilename));
6106	return INVALID_HANDLE_VALUE;
6107	}
6108	else if ( enmError == KFSLOOKUPERROR_PATH_COMP_NOT_FOUND
6109	\|\| enmError == KFSLOOKUPERROR_PATH_COMP_NOT_DIR)
6110	{
6111	KWFS_LOG(("CreateFileW(%ls) -> INVALID_HANDLE_VALUE, ERROR_PATH_NOT_FOUND\n", pwszFilename));
6112	return INVALID_HANDLE_VALUE;
6113	}
6114
6115	/* fallback */
6116	hFile = CreateFileW(pwszFilename, dwDesiredAccess, dwShareMode, pSecAttrs,
6117	dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
6118	KWFS_LOG(("CreateFileW(%ls) -> %p (err=%u) [fallback]\n", pwszFilename, hFile, GetLastError()));
6119	return hFile;
6120	}
6121	}
6122	else
6123	KWFS_LOG(("CreateFileW: incompatible security attributes (nLength=%#x pDesc=%p)\n",
6124	pSecAttrs->nLength, pSecAttrs->lpSecurityDescriptor));
6125	}
6126	else
6127	KWFS_LOG(("CreateFileW: incompatible sharing mode %#x\n", dwShareMode));
6128	}
6129	else
6130	KWFS_LOG(("CreateFileW: incompatible desired access %#x\n", dwDesiredAccess));
6131	}
6132	else
6133	KWFS_LOG(("CreateFileW: incompatible disposition %u\n", dwCreationDisposition));
6134
6135	/*
6136	* Okay, normal.
6137	*/
6138	hFile = CreateFileW(pwszFilename, dwDesiredAccess, dwShareMode, pSecAttrs,
6139	dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
6140	if (hFile != INVALID_HANDLE_VALUE)
6141	{
6142	kHlpAssert( KW_HANDLE_TO_INDEX(hFile) >= g_Sandbox.cHandles
6143	\|\| g_Sandbox.papHandles[KW_HANDLE_TO_INDEX(hFile)] == NULL);
6144	}
6145	KWFS_LOG(("CreateFileW(%ls) -> %p\n", pwszFilename, hFile));
6146	return hFile;
6147	}
6148
6149
6150	/** Kernel32 - SetFilePointer */
6151	static DWORD WINAPI kwSandbox_Kernel32_SetFilePointer(HANDLE hFile, LONG cbMove, PLONG pcbMoveHi, DWORD dwMoveMethod)
6152	{
6153	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6154	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6155	if (idxHandle < g_Sandbox.cHandles)
6156	{
6157	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6158	if (pHandle != NULL)
6159	{
6160	KU32 cbFile;
6161	KI64 offMove = pcbMoveHi ? ((KI64)*pcbMoveHi << 32) \| cbMove : cbMove;
6162	switch (pHandle->enmType)
6163	{
6164	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6165	cbFile = pHandle->u.pCachedFile->cbCached;
6166	break;
6167	#ifdef WITH_TEMP_MEMORY_FILES
6168	case KWHANDLETYPE_TEMP_FILE:
6169	cbFile = pHandle->u.pTempFile->cbFile;
6170	break;
6171	#endif
6172	case KWHANDLETYPE_TEMP_FILE_MAPPING:
6173	case KWHANDLETYPE_OUTPUT_BUF:
6174	default:
6175	kHlpAssertFailed();
6176	SetLastError(ERROR_INVALID_FUNCTION);
6177	return INVALID_SET_FILE_POINTER;
6178	}
6179
6180	switch (dwMoveMethod)
6181	{
6182	case FILE_BEGIN:
6183	break;
6184	case FILE_CURRENT:
6185	offMove += pHandle->offFile;
6186	break;
6187	case FILE_END:
6188	offMove += cbFile;
6189	break;
6190	default:
6191	KWFS_LOG(("SetFilePointer(%p) - invalid seek method %u! [cached]\n", hFile));
6192	SetLastError(ERROR_INVALID_PARAMETER);
6193	return INVALID_SET_FILE_POINTER;
6194	}
6195	if (offMove >= 0)
6196	{
6197	if (offMove >= (KSSIZE)cbFile)
6198	{
6199	/* For read-only files, seeking beyond the end isn't useful to us, so clamp it. */
6200	if (pHandle->enmType != KWHANDLETYPE_TEMP_FILE)
6201	offMove = (KSSIZE)cbFile;
6202	/* For writable files, seeking beyond the end is fine, but check that we've got
6203	the type range for the request. */
6204	else if (((KU64)offMove & KU32_MAX) != (KU64)offMove)
6205	{
6206	kHlpAssertMsgFailed(("%#llx\n", offMove));
6207	SetLastError(ERROR_SEEK);
6208	return INVALID_SET_FILE_POINTER;
6209	}
6210	}
6211	pHandle->offFile = (KU32)offMove;
6212	}
6213	else
6214	{
6215	KWFS_LOG(("SetFilePointer(%p) - negative seek! [cached]\n", hFile));
6216	SetLastError(ERROR_NEGATIVE_SEEK);
6217	return INVALID_SET_FILE_POINTER;
6218	}
6219	if (pcbMoveHi)
6220	*pcbMoveHi = (KU64)offMove >> 32;
6221	KWFS_LOG(("SetFilePointer(%p,%#x,?,%u) -> %#llx [%s]\n", hFile, cbMove, dwMoveMethod, offMove,
6222	pHandle->enmType == KWHANDLETYPE_FSOBJ_READ_CACHE ? "cached" : "temp"));
6223	SetLastError(NO_ERROR);
6224	return (KU32)offMove;
6225	}
6226	}
6227	KWFS_LOG(("SetFilePointer(%p, %d, %p=%d, %d)\n", hFile, cbMove, pcbMoveHi ? *pcbMoveHi : 0, dwMoveMethod));
6228	return SetFilePointer(hFile, cbMove, pcbMoveHi, dwMoveMethod);
6229	}
6230
6231
6232	/** Kernel32 - SetFilePointerEx */
6233	static BOOL WINAPI kwSandbox_Kernel32_SetFilePointerEx(HANDLE hFile, LARGE_INTEGER offMove, PLARGE_INTEGER poffNew,
6234	DWORD dwMoveMethod)
6235	{
6236	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6237	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6238	if (idxHandle < g_Sandbox.cHandles)
6239	{
6240	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6241	if (pHandle != NULL)
6242	{
6243	KI64 offMyMove = offMove.QuadPart;
6244	KU32 cbFile;
6245	switch (pHandle->enmType)
6246	{
6247	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6248	cbFile = pHandle->u.pCachedFile->cbCached;
6249	break;
6250	#ifdef WITH_TEMP_MEMORY_FILES
6251	case KWHANDLETYPE_TEMP_FILE:
6252	cbFile = pHandle->u.pTempFile->cbFile;
6253	break;
6254	#endif
6255	case KWHANDLETYPE_TEMP_FILE_MAPPING:
6256	case KWHANDLETYPE_OUTPUT_BUF:
6257	default:
6258	kHlpAssertFailed();
6259	SetLastError(ERROR_INVALID_FUNCTION);
6260	return INVALID_SET_FILE_POINTER;
6261	}
6262
6263	switch (dwMoveMethod)
6264	{
6265	case FILE_BEGIN:
6266	break;
6267	case FILE_CURRENT:
6268	offMyMove += pHandle->offFile;
6269	break;
6270	case FILE_END:
6271	offMyMove += cbFile;
6272	break;
6273	default:
6274	KWFS_LOG(("SetFilePointer(%p) - invalid seek method %u! [cached]\n", hFile));
6275	SetLastError(ERROR_INVALID_PARAMETER);
6276	return INVALID_SET_FILE_POINTER;
6277	}
6278	if (offMyMove >= 0)
6279	{
6280	if (offMyMove >= (KSSIZE)cbFile)
6281	{
6282	/* For read-only files, seeking beyond the end isn't useful to us, so clamp it. */
6283	if (pHandle->enmType != KWHANDLETYPE_TEMP_FILE)
6284	offMyMove = (KSSIZE)cbFile;
6285	/* For writable files, seeking beyond the end is fine, but check that we've got
6286	the type range for the request. */
6287	else if (((KU64)offMyMove & KU32_MAX) != (KU64)offMyMove)
6288	{
6289	kHlpAssertMsgFailed(("%#llx\n", offMyMove));
6290	SetLastError(ERROR_SEEK);
6291	return INVALID_SET_FILE_POINTER;
6292	}
6293	}
6294	pHandle->offFile = (KU32)offMyMove;
6295	}
6296	else
6297	{
6298	KWFS_LOG(("SetFilePointerEx(%p) - negative seek! [cached]\n", hFile));
6299	SetLastError(ERROR_NEGATIVE_SEEK);
6300	return INVALID_SET_FILE_POINTER;
6301	}
6302	if (poffNew)
6303	poffNew->QuadPart = offMyMove;
6304	KWFS_LOG(("SetFilePointerEx(%p,%#llx,,%u) -> TRUE, %#llx [%s]\n", hFile, offMove.QuadPart, dwMoveMethod, offMyMove,
6305	pHandle->enmType == KWHANDLETYPE_FSOBJ_READ_CACHE ? "cached" : "temp"));
6306	return TRUE;
6307	}
6308	}
6309	KWFS_LOG(("SetFilePointerEx(%p)\n", hFile));
6310	return SetFilePointerEx(hFile, offMove, poffNew, dwMoveMethod);
6311	}
6312
6313
6314	/** Kernel32 - ReadFile */
6315	static BOOL WINAPI kwSandbox_Kernel32_ReadFile(HANDLE hFile, LPVOID pvBuffer, DWORD cbToRead, LPDWORD pcbActuallyRead,
6316	LPOVERLAPPED pOverlapped)
6317	{
6318	BOOL fRet;
6319	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6320	g_cReadFileCalls++;
6321	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6322	if (idxHandle < g_Sandbox.cHandles)
6323	{
6324	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6325	if (pHandle != NULL)
6326	{
6327	switch (pHandle->enmType)
6328	{
6329	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6330	{
6331	PKFSWCACHEDFILE pCachedFile = pHandle->u.pCachedFile;
6332	KU32 cbActually = pCachedFile->cbCached - pHandle->offFile;
6333	if (cbActually > cbToRead)
6334	cbActually = cbToRead;
6335
6336	#ifdef WITH_HASH_MD5_CACHE
6337	if (g_Sandbox.pHashHead)
6338	{
6339	g_Sandbox.LastHashRead.pCachedFile = pCachedFile;
6340	g_Sandbox.LastHashRead.offRead = pHandle->offFile;
6341	g_Sandbox.LastHashRead.cbRead = cbActually;
6342	g_Sandbox.LastHashRead.pvRead = pvBuffer;
6343	}
6344	#endif
6345
6346	kHlpMemCopy(pvBuffer, &pCachedFile->pbCached[pHandle->offFile], cbActually);
6347	pHandle->offFile += cbActually;
6348
6349	kHlpAssert(!pOverlapped); kHlpAssert(pcbActuallyRead);
6350	*pcbActuallyRead = cbActually;
6351
6352	g_cbReadFileFromReadCached += cbActually;
6353	g_cbReadFileTotal += cbActually;
6354	g_cReadFileFromReadCached++;
6355
6356	KWFS_LOG(("ReadFile(%p,,%#x) -> TRUE, %#x bytes [cached]\n", hFile, cbToRead, cbActually));
6357	return TRUE;
6358	}
6359
6360	#ifdef WITH_TEMP_MEMORY_FILES
6361	case KWHANDLETYPE_TEMP_FILE:
6362	{
6363	PKWFSTEMPFILE pTempFile = pHandle->u.pTempFile;
6364	KU32 cbActually;
6365	if (pHandle->offFile < pTempFile->cbFile)
6366	{
6367	cbActually = pTempFile->cbFile - pHandle->offFile;
6368	if (cbActually > cbToRead)
6369	cbActually = cbToRead;
6370
6371	/* Copy the data. */
6372	if (cbActually > 0)
6373	{
6374	KU32 cbLeft;
6375	KU32 offSeg;
6376	KWFSTEMPFILESEG const *paSegs = pTempFile->paSegs;
6377
6378	/* Locate the segment containing the byte at offFile. */
6379	KU32 iSeg = pTempFile->cSegs - 1;
6380	kHlpAssert(pTempFile->cSegs > 0);
6381	while (paSegs[iSeg].offData > pHandle->offFile)
6382	iSeg--;
6383
6384	/* Copy out the data. */
6385	cbLeft = cbActually;
6386	offSeg = (pHandle->offFile - paSegs[iSeg].offData);
6387	for (;;)
6388	{
6389	KU32 cbAvail = paSegs[iSeg].cbDataAlloc - offSeg;
6390	if (cbAvail >= cbLeft)
6391	{
6392	kHlpMemCopy(pvBuffer, &paSegs[iSeg].pbData[offSeg], cbLeft);
6393	break;
6394	}
6395
6396	pvBuffer = kHlpMemPCopy(pvBuffer, &paSegs[iSeg].pbData[offSeg], cbAvail);
6397	cbLeft -= cbAvail;
6398	offSeg = 0;
6399	iSeg++;
6400	kHlpAssert(iSeg < pTempFile->cSegs);
6401	}
6402
6403	/* Update the file offset. */
6404	pHandle->offFile += cbActually;
6405	}
6406	}
6407	/* Read does not commit file space, so return zero bytes. */
6408	else
6409	cbActually = 0;
6410
6411	kHlpAssert(!pOverlapped); kHlpAssert(pcbActuallyRead);
6412	*pcbActuallyRead = cbActually;
6413
6414	g_cbReadFileTotal += cbActually;
6415	g_cbReadFileFromInMemTemp += cbActually;
6416	g_cReadFileFromInMemTemp++;
6417
6418	KWFS_LOG(("ReadFile(%p,,%#x) -> TRUE, %#x bytes [temp]\n", hFile, cbToRead, (KU32)cbActually));
6419	return TRUE;
6420	}
6421	#endif /* WITH_TEMP_MEMORY_FILES */
6422
6423	case KWHANDLETYPE_TEMP_FILE_MAPPING:
6424	case KWHANDLETYPE_OUTPUT_BUF:
6425	default:
6426	kHlpAssertFailed();
6427	SetLastError(ERROR_INVALID_FUNCTION);
6428	*pcbActuallyRead = 0;
6429	return FALSE;
6430	}
6431	}
6432	}
6433
6434	fRet = ReadFile(hFile, pvBuffer, cbToRead, pcbActuallyRead, pOverlapped);
6435	if (fRet && pcbActuallyRead)
6436	g_cbReadFileTotal += *pcbActuallyRead;
6437	KWFS_LOG(("ReadFile(%p,%p,%#x,,) -> %d, %#x\n", hFile, pvBuffer, cbToRead, fRet, pcbActuallyRead ? *pcbActuallyRead : 0));
6438	return fRet;
6439	}
6440
6441
6442	/** Kernel32 - ReadFileEx */
6443	static BOOL WINAPI kwSandbox_Kernel32_ReadFileEx(HANDLE hFile, LPVOID pvBuffer, DWORD cbToRead, LPOVERLAPPED pOverlapped,
6444	LPOVERLAPPED_COMPLETION_ROUTINE pfnCompletionRoutine)
6445	{
6446	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6447	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6448	if (idxHandle < g_Sandbox.cHandles)
6449	{
6450	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6451	if (pHandle != NULL)
6452	{
6453	kHlpAssertFailed();
6454	}
6455	}
6456
6457	KWFS_LOG(("ReadFile(%p)\n", hFile));
6458	return ReadFileEx(hFile, pvBuffer, cbToRead, pOverlapped, pfnCompletionRoutine);
6459	}
6460
6461	#ifdef WITH_STD_OUT_ERR_BUFFERING
6462
6463	/**
6464	* Write something to a handle, making sure everything is actually written.
6465	*
6466	* @param hHandle Where to write it to.
6467	* @param pchBuf What to write
6468	* @param cchToWrite How much to write.
6469	*/
6470	static void kwSandboxOutBufWriteIt(HANDLE hFile, char const *pchBuf, KU32 cchToWrite)
6471	{
6472	if (cchToWrite > 0)
6473	{
6474	DWORD cchWritten = 0;
6475	if (WriteFile(hFile, pchBuf, cchToWrite, &cchWritten, NULL))
6476	{
6477	if (cchWritten == cchToWrite)
6478	{ /* likely */ }
6479	else
6480	{
6481	do
6482	{
6483	pchBuf += cchWritten;
6484	cchToWrite -= cchWritten;
6485	cchWritten = 0;
6486	} while ( cchToWrite > 0
6487	&& WriteFile(hFile, pchBuf, cchToWrite, &cchWritten, NULL));
6488	}
6489	}
6490	else
6491	kHlpAssertFailed();
6492	}
6493	}
6494
6495
6496	/**
6497	* Worker for WriteFile when the output isn't going to the console.
6498	*
6499	* @param pSandbox The sandbox.
6500	* @param pOutBuf The output buffer.
6501	* @param pchBuffer What to write.
6502	* @param cchToWrite How much to write.
6503	*/
6504	static void kwSandboxOutBufWrite(PKWSANDBOX pSandbox, PKWOUTPUTSTREAMBUF pOutBuf, const char *pchBuffer, KU32 cchToWrite)
6505	{
6506	if (pOutBuf->u.Fully.cchBufAlloc > 0)
6507	{ /* likely */ }
6508	else
6509	{
6510	/* No realloc, max size is 64KB. */
6511	pOutBuf->u.Fully.cchBufAlloc = 0x10000;
6512	pOutBuf->u.Fully.pchBuf = (char *)kHlpAlloc(pOutBuf->u.Fully.cchBufAlloc);
6513	if (!pOutBuf->u.Fully.pchBuf)
6514	{
6515	while ( !pOutBuf->u.Fully.pchBuf
6516	&& pOutBuf->u.Fully.cchBufAlloc > 64)
6517	{
6518	pOutBuf->u.Fully.cchBufAlloc /= 2;
6519	pOutBuf->u.Fully.pchBuf = (char *)kHlpAlloc(pOutBuf->u.Fully.cchBufAlloc);
6520	}
6521	if (!pOutBuf->u.Fully.pchBuf)
6522	{
6523	pOutBuf->u.Fully.cchBufAlloc = sizeof(pOutBuf->abPadding);
6524	pOutBuf->u.Fully.pchBuf = pOutBuf->abPadding;
6525	}
6526	}
6527	}
6528
6529	/*
6530	* Special case: Output ends with newline and fits in the buffer.
6531	*/
6532	if ( cchToWrite > 1
6533	&& pchBuffer[cchToWrite - 1] == '\n'
6534	&& cchToWrite <= pOutBuf->u.Fully.cchBufAlloc - pOutBuf->u.Fully.cchBuf)
6535	{
6536	kHlpMemCopy(&pOutBuf->u.Fully.pchBuf[pOutBuf->u.Fully.cchBuf], pchBuffer, cchToWrite);
6537	pOutBuf->u.Fully.cchBuf += cchToWrite;
6538	}
6539	else
6540	{
6541	/*
6542	* Work thru the text line by line, flushing the buffer when
6543	* appropriate. The buffer is not a line buffer here, it's a
6544	* full buffer.
6545	*/
6546	while (cchToWrite > 0)
6547	{
6548	char const pchNewLine = (const char )memchr(pchBuffer, '\n', cchToWrite);
6549	KU32 cchLine = pchNewLine ? (KU32)(pchNewLine - pchBuffer) + 1 : cchToWrite;
6550	if (cchLine <= pOutBuf->u.Fully.cchBufAlloc - pOutBuf->u.Fully.cchBuf)
6551	{
6552	kHlpMemCopy(&pOutBuf->u.Fully.pchBuf[pOutBuf->u.Fully.cchBuf], pchBuffer, cchLine);
6553	pOutBuf->u.Fully.cchBuf += cchLine;
6554	}
6555	/*
6556	* Option one: Flush the buffer and the current line.
6557	*
6558	* We choose this one when the line won't ever fit, or when we have
6559	* an incomplete line in the buffer.
6560	*/
6561	else if ( cchLine >= pOutBuf->u.Fully.cchBufAlloc
6562	\|\| pOutBuf->u.Fully.cchBuf == 0
6563	\|\| pOutBuf->u.Fully.pchBuf[pOutBuf->u.Fully.cchBuf - 1] != '\n')
6564	{
6565	KWOUT_LOG(("kwSandboxOutBufWrite: flushing %u bytes, writing %u bytes\n", pOutBuf->u.Fully.cchBuf, cchLine));
6566	if (pOutBuf->u.Fully.cchBuf > 0)
6567	{
6568	kwSandboxOutBufWriteIt(pOutBuf->hBackup, pOutBuf->u.Fully.pchBuf, pOutBuf->u.Fully.cchBuf);
6569	pOutBuf->u.Fully.cchBuf = 0;
6570	}
6571	kwSandboxOutBufWriteIt(pOutBuf->hBackup, pchBuffer, cchLine);
6572	}
6573	/*
6574	* Option two: Only flush the lines in the buffer.
6575	*/
6576	else
6577	{
6578	KWOUT_LOG(("kwSandboxOutBufWrite: flushing %u bytes\n", pOutBuf->u.Fully.cchBuf));
6579	kwSandboxOutBufWriteIt(pOutBuf->hBackup, pOutBuf->u.Fully.pchBuf, pOutBuf->u.Fully.cchBuf);
6580	kHlpMemCopy(&pOutBuf->u.Fully.pchBuf[0], pchBuffer, cchLine);
6581	pOutBuf->u.Fully.cchBuf = cchLine;
6582	}
6583
6584	/* advance */
6585	pchBuffer += cchLine;
6586	cchToWrite -= cchLine;
6587	}
6588	}
6589	}
6590
6591	#endif /* WITH_STD_OUT_ERR_BUFFERING */
6592
6593	#ifdef WITH_TEMP_MEMORY_FILES
6594	static KBOOL kwFsTempFileEnsureSpace(PKWFSTEMPFILE pTempFile, KU32 offFile, KU32 cbNeeded)
6595	{
6596	KU32 cbMinFile = offFile + cbNeeded;
6597	if (cbMinFile >= offFile)
6598	{
6599	/* Calc how much space we've already allocated and */
6600	if (cbMinFile <= pTempFile->cbFileAllocated)
6601	return K_TRUE;
6602
6603	/* Grow the file. */
6604	if (cbMinFile <= KWFS_TEMP_FILE_MAX)
6605	{
6606	int rc;
6607	KU32 cSegs = pTempFile->cSegs;
6608	KU32 cbNewSeg = cbMinFile > 410241024 ? 2561024 : 41024*1024;
6609	do
6610	{
6611	/* grow the segment array? */
6612	if ((cSegs % 16) == 0)
6613	{
6614	void pvNew = kHlpRealloc(pTempFile->paSegs, (cSegs + 16) sizeof(pTempFile->paSegs[0]));
6615	if (!pvNew)
6616	return K_FALSE;
6617	pTempFile->paSegs = (PKWFSTEMPFILESEG)pvNew;
6618	}
6619
6620	/* Use page alloc here to simplify mapping later. */
6621	rc = kHlpPageAlloc((void **)&pTempFile->paSegs[cSegs].pbData, cbNewSeg, KPROT_READWRITE, K_FALSE);
6622	if (rc == 0)
6623	{ /* likely */ }
6624	else
6625	{
6626	cbNewSeg = 64*1024;
6627	rc = kHlpPageAlloc((void **)&pTempFile->paSegs[cSegs].pbData, cbNewSeg, KPROT_READWRITE, K_FALSE);
6628	if (rc != 0)
6629	{
6630	kHlpAssertFailed();
6631	return K_FALSE;
6632	}
6633	}
6634	pTempFile->paSegs[cSegs].offData = pTempFile->cbFileAllocated;
6635	pTempFile->paSegs[cSegs].cbDataAlloc = cbNewSeg;
6636	pTempFile->cbFileAllocated += cbNewSeg;
6637	pTempFile->cSegs = ++cSegs;
6638
6639	} while (pTempFile->cbFileAllocated < cbMinFile);
6640
6641	return K_TRUE;
6642	}
6643	}
6644
6645	kHlpAssertMsgFailed(("Out of bounds offFile=%#x + cbNeeded=%#x = %#x\n", offFile, cbNeeded, offFile + cbNeeded));
6646	return K_FALSE;
6647	}
6648	#endif /* WITH_TEMP_MEMORY_FILES */
6649
6650
6651	#if defined(WITH_TEMP_MEMORY_FILES) \|\| defined(WITH_STD_OUT_ERR_BUFFERING)
6652	/** Kernel32 - WriteFile */
6653	static BOOL WINAPI kwSandbox_Kernel32_WriteFile(HANDLE hFile, LPCVOID pvBuffer, DWORD cbToWrite, LPDWORD pcbActuallyWritten,
6654	LPOVERLAPPED pOverlapped)
6655	{
6656	BOOL fRet;
6657	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6658	g_cWriteFileCalls++;
6659	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread \|\| g_fCtrlC);
6660	if (idxHandle < g_Sandbox.cHandles)
6661	{
6662	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6663	if (pHandle != NULL)
6664	{
6665	switch (pHandle->enmType)
6666	{
6667	# ifdef WITH_TEMP_MEMORY_FILES
6668	case KWHANDLETYPE_TEMP_FILE:
6669	{
6670	PKWFSTEMPFILE pTempFile = pHandle->u.pTempFile;
6671
6672	kHlpAssert(!pOverlapped);
6673	kHlpAssert(pcbActuallyWritten);
6674
6675	if (kwFsTempFileEnsureSpace(pTempFile, pHandle->offFile, cbToWrite))
6676	{
6677	KU32 cbLeft;
6678	KU32 offSeg;
6679
6680	/* Locate the segment containing the byte at offFile. */
6681	KWFSTEMPFILESEG const *paSegs = pTempFile->paSegs;
6682	KU32 iSeg = pTempFile->cSegs - 1;
6683	kHlpAssert(pTempFile->cSegs > 0);
6684	while (paSegs[iSeg].offData > pHandle->offFile)
6685	iSeg--;
6686
6687	/* Copy in the data. */
6688	cbLeft = cbToWrite;
6689	offSeg = (pHandle->offFile - paSegs[iSeg].offData);
6690	for (;;)
6691	{
6692	KU32 cbAvail = paSegs[iSeg].cbDataAlloc - offSeg;
6693	if (cbAvail >= cbLeft)
6694	{
6695	kHlpMemCopy(&paSegs[iSeg].pbData[offSeg], pvBuffer, cbLeft);
6696	break;
6697	}
6698
6699	kHlpMemCopy(&paSegs[iSeg].pbData[offSeg], pvBuffer, cbAvail);
6700	pvBuffer = (KU8 const *)pvBuffer + cbAvail;
6701	cbLeft -= cbAvail;
6702	offSeg = 0;
6703	iSeg++;
6704	kHlpAssert(iSeg < pTempFile->cSegs);
6705	}
6706
6707	/* Update the file offset. */
6708	pHandle->offFile += cbToWrite;
6709	if (pHandle->offFile > pTempFile->cbFile)
6710	pTempFile->cbFile = pHandle->offFile;
6711
6712	*pcbActuallyWritten = cbToWrite;
6713
6714	g_cbWriteFileTotal += cbToWrite;
6715	g_cbWriteFileToInMemTemp += cbToWrite;
6716	g_cWriteFileToInMemTemp++;
6717
6718	KWFS_LOG(("WriteFile(%p,,%#x) -> TRUE [temp]\n", hFile, cbToWrite));
6719	return TRUE;
6720	}
6721
6722	kHlpAssertFailed();
6723	*pcbActuallyWritten = 0;
6724	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
6725	return FALSE;
6726	}
6727	# endif
6728
6729	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6730	kHlpAssertFailed();
6731	SetLastError(ERROR_ACCESS_DENIED);
6732	*pcbActuallyWritten = 0;
6733	return FALSE;
6734
6735	# if defined(WITH_STD_OUT_ERR_BUFFERING) \|\| defined(WITH_CONSOLE_OUTPUT_BUFFERING)
6736	/*
6737	* Standard output & error.
6738	*/
6739	case KWHANDLETYPE_OUTPUT_BUF:
6740	{
6741	PKWOUTPUTSTREAMBUF pOutBuf = pHandle->u.pOutBuf;
6742	if (pOutBuf->fIsConsole)
6743	{
6744	kwSandboxConsoleWriteA(&g_Sandbox, pOutBuf, (const char *)pvBuffer, cbToWrite);
6745	KWOUT_LOG(("WriteFile(%p [console]) -> TRUE\n", hFile));
6746	}
6747	else
6748	{
6749	# ifdef WITH_STD_OUT_ERR_BUFFERING
6750	kwSandboxOutBufWrite(&g_Sandbox, pOutBuf, (const char *)pvBuffer, cbToWrite);
6751	KWOUT_LOG(("WriteFile(%p [std%s], 's.', %#x) -> TRUE\n", hFile,
6752	pOutBuf == &g_Sandbox.StdErr ? "err" : "out", cbToWrite, cbToWrite, pvBuffer, cbToWrite));
6753	# else
6754	kHlpAssertFailed();
6755	# endif
6756	}
6757	if (pcbActuallyWritten)
6758	*pcbActuallyWritten = cbToWrite;
6759	g_cbWriteFileTotal += cbToWrite;
6760	return TRUE;
6761	}
6762	# endif
6763
6764	default:
6765	case KWHANDLETYPE_TEMP_FILE_MAPPING:
6766	kHlpAssertFailed();
6767	SetLastError(ERROR_INVALID_FUNCTION);
6768	*pcbActuallyWritten = 0;
6769	return FALSE;
6770	}
6771	}
6772	}
6773
6774	fRet = WriteFile(hFile, pvBuffer, cbToWrite, pcbActuallyWritten, pOverlapped);
6775	if (fRet && pcbActuallyWritten)
6776	g_cbWriteFileTotal += *pcbActuallyWritten;
6777	KWFS_LOG(("WriteFile(%p,,%#x) -> %d, %#x\n", hFile, cbToWrite, fRet, pcbActuallyWritten ? *pcbActuallyWritten : 0));
6778	return fRet;
6779	}
6780
6781
6782	/** Kernel32 - WriteFileEx */
6783	static BOOL WINAPI kwSandbox_Kernel32_WriteFileEx(HANDLE hFile, LPCVOID pvBuffer, DWORD cbToWrite, LPOVERLAPPED pOverlapped,
6784	LPOVERLAPPED_COMPLETION_ROUTINE pfnCompletionRoutine)
6785	{
6786	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6787	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6788	if (idxHandle < g_Sandbox.cHandles)
6789	{
6790	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6791	if (pHandle != NULL)
6792	{
6793	kHlpAssertFailed();
6794	}
6795	}
6796
6797	KWFS_LOG(("WriteFileEx(%p)\n", hFile));
6798	return WriteFileEx(hFile, pvBuffer, cbToWrite, pOverlapped, pfnCompletionRoutine);
6799	}
6800
6801	#endif /* WITH_TEMP_MEMORY_FILES \|\| WITH_STD_OUT_ERR_BUFFERING */
6802
6803	#ifdef WITH_TEMP_MEMORY_FILES
6804
6805	/** Kernel32 - SetEndOfFile; */
6806	static BOOL WINAPI kwSandbox_Kernel32_SetEndOfFile(HANDLE hFile)
6807	{
6808	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6809	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6810	if (idxHandle < g_Sandbox.cHandles)
6811	{
6812	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6813	if (pHandle != NULL)
6814	{
6815	switch (pHandle->enmType)
6816	{
6817	case KWHANDLETYPE_TEMP_FILE:
6818	{
6819	PKWFSTEMPFILE pTempFile = pHandle->u.pTempFile;
6820	if ( pHandle->offFile > pTempFile->cbFile
6821	&& !kwFsTempFileEnsureSpace(pTempFile, pHandle->offFile, 0))
6822	{
6823	kHlpAssertFailed();
6824	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
6825	return FALSE;
6826	}
6827
6828	pTempFile->cbFile = pHandle->offFile;
6829	KWFS_LOG(("SetEndOfFile(%p) -> TRUE (cbFile=%#x)\n", hFile, pTempFile->cbFile));
6830	return TRUE;
6831	}
6832
6833	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6834	kHlpAssertFailed();
6835	SetLastError(ERROR_ACCESS_DENIED);
6836	return FALSE;
6837
6838	case KWHANDLETYPE_OUTPUT_BUF:
6839	kHlpAssertFailed();
6840	SetLastError(pHandle->u.pOutBuf->fIsConsole ? ERROR_INVALID_OPERATION : ERROR_ACCESS_DENIED);
6841	return FALSE;
6842
6843	default:
6844	case KWHANDLETYPE_TEMP_FILE_MAPPING:
6845	kHlpAssertFailed();
6846	SetLastError(ERROR_INVALID_FUNCTION);
6847	return FALSE;
6848	}
6849	}
6850	}
6851
6852	KWFS_LOG(("SetEndOfFile(%p)\n", hFile));
6853	return SetEndOfFile(hFile);
6854	}
6855
6856
6857	/** Kernel32 - GetFileType */
6858	static BOOL WINAPI kwSandbox_Kernel32_GetFileType(HANDLE hFile)
6859	{
6860	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6861	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6862	if (idxHandle < g_Sandbox.cHandles)
6863	{
6864	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6865	if (pHandle != NULL)
6866	{
6867	switch (pHandle->enmType)
6868	{
6869	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6870	KWFS_LOG(("GetFileType(%p) -> FILE_TYPE_DISK [cached]\n", hFile));
6871	return FILE_TYPE_DISK;
6872
6873	case KWHANDLETYPE_TEMP_FILE:
6874	KWFS_LOG(("GetFileType(%p) -> FILE_TYPE_DISK [temp]\n", hFile));
6875	return FILE_TYPE_DISK;
6876
6877	case KWHANDLETYPE_OUTPUT_BUF:
6878	{
6879	PKWOUTPUTSTREAMBUF pOutBuf = pHandle->u.pOutBuf;
6880	DWORD fRet;
6881	if (pOutBuf->fFileType != KU8_MAX)
6882	{
6883	fRet = (pOutBuf->fFileType & 0xf) \| ((pOutBuf->fFileType & (FILE_TYPE_REMOTE >> 8)) << 8);
6884	KWFS_LOG(("GetFileType(%p) -> %#x [outbuf]\n", hFile, fRet));
6885	}
6886	else
6887	{
6888	fRet = GetFileType(hFile);
6889	KWFS_LOG(("GetFileType(%p) -> %#x [outbuf, fallback]\n", hFile, fRet));
6890	}
6891	return fRet;
6892	}
6893
6894	}
6895	}
6896	}
6897
6898	KWFS_LOG(("GetFileType(%p)\n", hFile));
6899	return GetFileType(hFile);
6900	}
6901
6902
6903	/** Kernel32 - GetFileSize */
6904	static DWORD WINAPI kwSandbox_Kernel32_GetFileSize(HANDLE hFile, LPDWORD pcbHighDword)
6905	{
6906	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6907	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6908	if (idxHandle < g_Sandbox.cHandles)
6909	{
6910	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6911	if (pHandle != NULL)
6912	{
6913	if (pcbHighDword)
6914	*pcbHighDword = 0;
6915	SetLastError(NO_ERROR);
6916	switch (pHandle->enmType)
6917	{
6918	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6919	KWFS_LOG(("GetFileSize(%p) -> %#x [cached]\n", hFile, pHandle->u.pCachedFile->cbCached));
6920	return pHandle->u.pCachedFile->cbCached;
6921
6922	case KWHANDLETYPE_TEMP_FILE:
6923	KWFS_LOG(("GetFileSize(%p) -> %#x [temp]\n", hFile, pHandle->u.pTempFile->cbFile));
6924	return pHandle->u.pTempFile->cbFile;
6925
6926	case KWHANDLETYPE_OUTPUT_BUF:
6927	/* do default */
6928	break;
6929
6930	default:
6931	kHlpAssertFailed();
6932	SetLastError(ERROR_INVALID_FUNCTION);
6933	return INVALID_FILE_SIZE;
6934	}
6935	}
6936	}
6937
6938	KWFS_LOG(("GetFileSize(%p,)\n", hFile));
6939	return GetFileSize(hFile, pcbHighDword);
6940	}
6941
6942
6943	/** Kernel32 - GetFileSizeEx */
6944	static BOOL WINAPI kwSandbox_Kernel32_GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER pcbFile)
6945	{
6946	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6947	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6948	if (idxHandle < g_Sandbox.cHandles)
6949	{
6950	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6951	if (pHandle != NULL)
6952	{
6953	switch (pHandle->enmType)
6954	{
6955	case KWHANDLETYPE_FSOBJ_READ_CACHE:
6956	KWFS_LOG(("GetFileSizeEx(%p) -> TRUE, %#x [cached]\n", hFile, pHandle->u.pCachedFile->cbCached));
6957	pcbFile->QuadPart = pHandle->u.pCachedFile->cbCached;
6958	return TRUE;
6959
6960	case KWHANDLETYPE_TEMP_FILE:
6961	KWFS_LOG(("GetFileSizeEx(%p) -> TRUE, %#x [temp]\n", hFile, pHandle->u.pTempFile->cbFile));
6962	pcbFile->QuadPart = pHandle->u.pTempFile->cbFile;
6963	return TRUE;
6964
6965	case KWHANDLETYPE_OUTPUT_BUF:
6966	/* do default */
6967	break;
6968
6969	default:
6970	kHlpAssertFailed();
6971	SetLastError(ERROR_INVALID_FUNCTION);
6972	return INVALID_FILE_SIZE;
6973	}
6974	}
6975	}
6976
6977	KWFS_LOG(("GetFileSizeEx(%p,)\n", hFile));
6978	return GetFileSizeEx(hFile, pcbFile);
6979	}
6980
6981
6982	/** Kernel32 - CreateFileMappingW */
6983	static HANDLE WINAPI kwSandbox_Kernel32_CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES pSecAttrs,
6984	DWORD fProtect, DWORD dwMaximumSizeHigh,
6985	DWORD dwMaximumSizeLow, LPCWSTR pwszName)
6986	{
6987	HANDLE hMapping;
6988	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hFile);
6989	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
6990	if (idxHandle < g_Sandbox.cHandles)
6991	{
6992	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
6993	if (pHandle != NULL)
6994	{
6995	switch (pHandle->enmType)
6996	{
6997	case KWHANDLETYPE_TEMP_FILE:
6998	{
6999	PKWFSTEMPFILE pTempFile = pHandle->u.pTempFile;
7000	if ( ( fProtect == PAGE_READONLY
7001	\|\| fProtect == PAGE_EXECUTE_READ)
7002	&& dwMaximumSizeHigh == 0
7003	&& ( dwMaximumSizeLow == 0
7004	\|\| dwMaximumSizeLow == pTempFile->cbFile)
7005	&& pwszName == NULL)
7006	{
7007	hMapping = kwFsTempFileCreateHandle(pHandle->u.pTempFile, GENERIC_READ, K_TRUE /fMapping/);
7008	KWFS_LOG(("CreateFileMappingW(%p, %u) -> %p [temp]\n", hFile, fProtect, hMapping));
7009	return hMapping;
7010	}
7011	kHlpAssertMsgFailed(("fProtect=%#x cb=%#x'%08x name=%p\n",
7012	fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName));
7013	SetLastError(ERROR_ACCESS_DENIED);
7014	return INVALID_HANDLE_VALUE;
7015	}
7016
7017	/* moc.exe benefits from this. */
7018	case KWHANDLETYPE_FSOBJ_READ_CACHE:
7019	{
7020	PKFSWCACHEDFILE pCachedFile = pHandle->u.pCachedFile;
7021	if ( ( fProtect == PAGE_READONLY
7022	\|\| fProtect == PAGE_EXECUTE_READ)
7023	&& dwMaximumSizeHigh == 0
7024	&& ( dwMaximumSizeLow == 0
7025	\|\| dwMaximumSizeLow == pCachedFile->cbCached)
7026	&& pwszName == NULL)
7027	{
7028	if (kwFsObjCacheCreateFileHandle(pCachedFile, GENERIC_READ, FALSE /fInheritHandle/,
7029	K_FALSE /fIsFileHandle/, &hMapping))
7030	{ /* likely */ }
7031	else
7032	hMapping = NULL;
7033	KWFS_LOG(("CreateFileMappingW(%p, %u) -> %p [cached]\n", hFile, fProtect, hMapping));
7034	return hMapping;
7035	}
7036
7037	/* Do fallback (for .pch). */
7038	kHlpAssertMsg(fProtect == PAGE_WRITECOPY,
7039	("fProtect=%#x cb=%#x'%08x name=%p\n",
7040	fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName));
7041
7042	hMapping = CreateFileMappingW(hFile, pSecAttrs, fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName);
7043	KWFS_LOG(("CreateFileMappingW(%p, %p, %#x, %#x, %#x, %p) -> %p [cached-fallback]\n",
7044	hFile, pSecAttrs, fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName, hMapping));
7045	return hMapping;
7046	}
7047
7048	/** @todo read cached memory mapped files too for moc. */
7049	}
7050	}
7051	}
7052
7053	hMapping = CreateFileMappingW(hFile, pSecAttrs, fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName);
7054	KWFS_LOG(("CreateFileMappingW(%p, %p, %#x, %#x, %#x, %p) -> %p\n",
7055	hFile, pSecAttrs, fProtect, dwMaximumSizeHigh, dwMaximumSizeLow, pwszName, hMapping));
7056	return hMapping;
7057	}
7058
7059
7060	/** Kernel32 - MapViewOfFile */
7061	static PVOID WINAPI kwSandbox_Kernel32_MapViewOfFile(HANDLE hSection, DWORD dwDesiredAccess,
7062	DWORD offFileHigh, DWORD offFileLow, SIZE_T cbToMap)
7063	{
7064	PVOID pvRet;
7065	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hSection);
7066	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7067	if (idxHandle < g_Sandbox.cHandles)
7068	{
7069	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
7070	if (pHandle != NULL)
7071	{
7072	KU32 idxMapping;
7073
7074	/*
7075	* Ensure one free entry in the mapping tracking table first,
7076	* since this is common to both temporary and cached files.
7077	*/
7078	if (g_Sandbox.cMemMappings + 1 <= g_Sandbox.cMemMappingsAlloc)
7079	{ /* likely */ }
7080	else
7081	{
7082	void *pvNew;
7083	KU32 cNew = g_Sandbox.cMemMappingsAlloc;
7084	if (cNew)
7085	cNew *= 2;
7086	else
7087	cNew = 32;
7088	pvNew = kHlpRealloc(g_Sandbox.paMemMappings, cNew * sizeof(g_Sandbox.paMemMappings));
7089	if (pvNew)
7090	g_Sandbox.paMemMappings = (PKWMEMMAPPING)pvNew;
7091	else
7092	{
7093	kwErrPrintf("Failed to grow paMemMappings from %#x to %#x!\n", g_Sandbox.cMemMappingsAlloc, cNew);
7094	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7095	return NULL;
7096	}
7097	g_Sandbox.cMemMappingsAlloc = cNew;
7098	}
7099
7100	/*
7101	* Type specific work.
7102	*/
7103	switch (pHandle->enmType)
7104	{
7105	case KWHANDLETYPE_FSOBJ_READ_CACHE:
7106	case KWHANDLETYPE_TEMP_FILE:
7107	case KWHANDLETYPE_OUTPUT_BUF:
7108	default:
7109	kHlpAssertFailed();
7110	SetLastError(ERROR_INVALID_OPERATION);
7111	return NULL;
7112
7113	case KWHANDLETYPE_TEMP_FILE_MAPPING:
7114	{
7115	PKWFSTEMPFILE pTempFile = pHandle->u.pTempFile;
7116	if ( dwDesiredAccess == FILE_MAP_READ
7117	&& offFileHigh == 0
7118	&& offFileLow == 0
7119	&& (cbToMap == 0 \|\| cbToMap == pTempFile->cbFile) )
7120	{
7121	kHlpAssert(pTempFile->cMappings == 0 \|\| pTempFile->cSegs == 1);
7122	if (pTempFile->cSegs != 1)
7123	{
7124	KU32 iSeg;
7125	KU32 cbLeft;
7126	KU32 cbAll = pTempFile->cbFile ? (KU32)K_ALIGN_Z(pTempFile->cbFile, 0x2000) : 0x1000;
7127	KU8 *pbAll = NULL;
7128	int rc = kHlpPageAlloc((void **)&pbAll, cbAll, KPROT_READWRITE, K_FALSE);
7129	if (rc != 0)
7130	{
7131	kHlpAssertFailed();
7132	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7133	return NULL;
7134	}
7135
7136	cbLeft = pTempFile->cbFile;
7137	for (iSeg = 0; iSeg < pTempFile->cSegs && cbLeft > 0; iSeg++)
7138	{
7139	KU32 cbToCopy = K_MIN(cbLeft, pTempFile->paSegs[iSeg].cbDataAlloc);
7140	kHlpMemCopy(&pbAll[pTempFile->paSegs[iSeg].offData], pTempFile->paSegs[iSeg].pbData, cbToCopy);
7141	cbLeft -= cbToCopy;
7142	}
7143
7144	for (iSeg = 0; iSeg < pTempFile->cSegs; iSeg++)
7145	{
7146	kHlpPageFree(pTempFile->paSegs[iSeg].pbData, pTempFile->paSegs[iSeg].cbDataAlloc);
7147	pTempFile->paSegs[iSeg].pbData = NULL;
7148	pTempFile->paSegs[iSeg].cbDataAlloc = 0;
7149	}
7150
7151	pTempFile->cSegs = 1;
7152	pTempFile->cbFileAllocated = cbAll;
7153	pTempFile->paSegs[0].cbDataAlloc = cbAll;
7154	pTempFile->paSegs[0].pbData = pbAll;
7155	pTempFile->paSegs[0].offData = 0;
7156	}
7157
7158	pTempFile->cMappings++;
7159	kHlpAssert(pTempFile->cMappings == 1);
7160
7161	pvRet = pTempFile->paSegs[0].pbData;
7162	KWFS_LOG(("CreateFileMappingW(%p) -> %p [temp]\n", hSection, pvRet));
7163	break;
7164	}
7165
7166	kHlpAssertMsgFailed(("dwDesiredAccess=%#x offFile=%#x'%08x cbToMap=%#x (cbFile=%#x)\n",
7167	dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pTempFile->cbFile));
7168	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7169	return NULL;
7170	}
7171
7172	/*
7173	* This is simple in comparison to the above temporary file code.
7174	*/
7175	case KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING:
7176	{
7177	PKFSWCACHEDFILE pCachedFile = pHandle->u.pCachedFile;
7178	if ( dwDesiredAccess == FILE_MAP_READ
7179	&& offFileHigh == 0
7180	&& offFileLow == 0
7181	&& (cbToMap == 0 \|\| cbToMap == pCachedFile->cbCached) )
7182	{
7183	pvRet = pCachedFile->pbCached;
7184	KWFS_LOG(("CreateFileMappingW(%p) -> %p [cached]\n", hSection, pvRet));
7185	break;
7186	}
7187	kHlpAssertMsgFailed(("dwDesiredAccess=%#x offFile=%#x'%08x cbToMap=%#x (cbFile=%#x)\n",
7188	dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pCachedFile->cbCached));
7189	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7190	return NULL;
7191	}
7192	}
7193
7194	/*
7195	* Insert into the mapping tracking table. This is common
7196	* and we should only get here with a non-NULL pvRet.
7197	*
7198	* Note! We could look for duplicates and do ref counting, but it's
7199	* easier to just append for now.
7200	*/
7201	kHlpAssert(pvRet != NULL);
7202	idxMapping = g_Sandbox.cMemMappings;
7203	kHlpAssert(idxMapping < g_Sandbox.cMemMappingsAlloc);
7204
7205	g_Sandbox.paMemMappings[idxMapping].cRefs = 1;
7206	g_Sandbox.paMemMappings[idxMapping].pvMapping = pvRet;
7207	g_Sandbox.paMemMappings[idxMapping].enmType = pHandle->enmType;
7208	g_Sandbox.paMemMappings[idxMapping].u.pCachedFile = pHandle->u.pCachedFile;
7209	g_Sandbox.cMemMappings++;
7210
7211	return pvRet;
7212	}
7213	}
7214
7215	pvRet = MapViewOfFile(hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap);
7216	KWFS_LOG(("MapViewOfFile(%p, %#x, %#x, %#x, %#x) -> %p\n",
7217	hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pvRet));
7218	return pvRet;
7219	}
7220
7221
7222	/** Kernel32 - MapViewOfFileEx */
7223	static PVOID WINAPI kwSandbox_Kernel32_MapViewOfFileEx(HANDLE hSection, DWORD dwDesiredAccess,
7224	DWORD offFileHigh, DWORD offFileLow, SIZE_T cbToMap, PVOID pvMapAddr)
7225	{
7226	PVOID pvRet;
7227	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hSection);
7228	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7229	if (idxHandle < g_Sandbox.cHandles)
7230	{
7231	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
7232	if (pHandle != NULL)
7233	{
7234	switch (pHandle->enmType)
7235	{
7236	case KWHANDLETYPE_TEMP_FILE_MAPPING:
7237	KWFS_LOG(("MapViewOfFileEx(%p, %#x, %#x, %#x, %#x, %p) - temporary file!\n",
7238	hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pvMapAddr));
7239	if (!pvMapAddr)
7240	return kwSandbox_Kernel32_MapViewOfFile(hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap);
7241	kHlpAssertFailed();
7242	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7243	return NULL;
7244
7245	case KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING:
7246	KWFS_LOG(("MapViewOfFileEx(%p, %#x, %#x, %#x, %#x, %p) - read cached file!\n",
7247	hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pvMapAddr));
7248	if (!pvMapAddr)
7249	return kwSandbox_Kernel32_MapViewOfFile(hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap);
7250	/* We can use fallback here as the handle is an actual section handle. */
7251	break;
7252
7253	case KWHANDLETYPE_FSOBJ_READ_CACHE:
7254	case KWHANDLETYPE_TEMP_FILE:
7255	case KWHANDLETYPE_OUTPUT_BUF:
7256	default:
7257	kHlpAssertFailed();
7258	SetLastError(ERROR_INVALID_OPERATION);
7259	return NULL;
7260	}
7261	}
7262	}
7263
7264	pvRet = MapViewOfFileEx(hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pvMapAddr);
7265	KWFS_LOG(("MapViewOfFileEx(%p, %#x, %#x, %#x, %#x, %p) -> %p\n",
7266	hSection, dwDesiredAccess, offFileHigh, offFileLow, cbToMap, pvMapAddr, pvRet));
7267	return pvRet;
7268
7269	}
7270
7271	/** Kernel32 - UnmapViewOfFile */
7272	static BOOL WINAPI kwSandbox_Kernel32_UnmapViewOfFile(LPCVOID pvBase)
7273	{
7274	/*
7275	* Consult the memory mapping tracker.
7276	*/
7277	PKWMEMMAPPING paMemMappings = g_Sandbox.paMemMappings;
7278	KU32 idxMapping = g_Sandbox.cMemMappings;
7279	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7280	while (idxMapping-- > 0)
7281	if (paMemMappings[idxMapping].pvMapping == pvBase)
7282	{
7283	/* Type specific stuff. */
7284	if (paMemMappings[idxMapping].enmType == KWHANDLETYPE_TEMP_FILE_MAPPING)
7285	{
7286	KWFS_LOG(("UnmapViewOfFile(%p) -> TRUE [temp]\n", pvBase));
7287	paMemMappings[idxMapping].u.pTempFile->cMappings--;
7288	}
7289	else
7290	KWFS_LOG(("UnmapViewOfFile(%p) -> TRUE [cached]\n", pvBase));
7291
7292	/* Deref and probably free it. */
7293	if (--paMemMappings[idxMapping].cRefs == 0)
7294	{
7295	g_Sandbox.cMemMappings--;
7296	if (idxMapping != g_Sandbox.cMemMappings)
7297	paMemMappings[idxMapping] = paMemMappings[g_Sandbox.cMemMappings];
7298	}
7299	return TRUE;
7300	}
7301
7302	KWFS_LOG(("UnmapViewOfFile(%p)\n", pvBase));
7303	return UnmapViewOfFile(pvBase);
7304	}
7305
7306	/** @todo UnmapViewOfFileEx */
7307
7308	#endif /* WITH_TEMP_MEMORY_FILES */
7309
7310
7311	/** Kernel32 - DuplicateHandle */
7312	static BOOL WINAPI kwSandbox_Kernel32_DuplicateHandle(HANDLE hSrcProc, HANDLE hSrc, HANDLE hDstProc, PHANDLE phNew,
7313	DWORD dwDesiredAccess, BOOL fInheritHandle, DWORD dwOptions)
7314	{
7315	BOOL fRet;
7316
7317	/*
7318	* We must catch our handles being duplicated.
7319	*/
7320	if (hSrcProc == GetCurrentProcess())
7321	{
7322	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hSrc);
7323	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7324	if (idxHandle < g_Sandbox.cHandles)
7325	{
7326	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
7327	if (pHandle)
7328	{
7329	fRet = DuplicateHandle(hSrcProc, hSrc, hDstProc, phNew, dwDesiredAccess, fInheritHandle, dwOptions);
7330	if (fRet)
7331	{
7332	if (kwSandboxHandleTableEnter(&g_Sandbox, pHandle, *phNew))
7333	{
7334	pHandle->cRefs++;
7335	KWFS_LOG(("DuplicateHandle(%p, %p, %p, , %#x, %d, %#x) -> TRUE, %p [intercepted handle] enmType=%d cRef=%d\n",
7336	hSrcProc, hSrc, hDstProc, dwDesiredAccess, fInheritHandle, dwOptions, *phNew,
7337	pHandle->enmType, pHandle->cRefs));
7338	}
7339	else
7340	{
7341	fRet = FALSE;
7342	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7343	KWFS_LOG(("DuplicateHandle(%p, %p, %p, , %#x, %d, %#x) -> !FALSE!, %p [intercepted handle] enmType=%d\n",
7344	hSrcProc, hSrc, hDstProc, dwDesiredAccess, fInheritHandle, dwOptions, *phNew, pHandle->enmType));
7345	}
7346	}
7347	else
7348	KWFS_LOG(("DuplicateHandle(%p, %p, %p, , %#x, %d, %#x) -> FALSE [intercepted handle] enmType=%d\n",
7349	hSrcProc, hSrc, hDstProc, dwDesiredAccess, fInheritHandle, dwOptions, pHandle->enmType));
7350	return fRet;
7351	}
7352	}
7353	}
7354
7355	/*
7356	* Not one of ours, just do what the caller asks and log it.
7357	*/
7358	fRet = DuplicateHandle(hSrcProc, hSrc, hDstProc, phNew, dwDesiredAccess, fInheritHandle, dwOptions);
7359	KWFS_LOG(("DuplicateHandle(%p, %p, %p, , %#x, %d, %#x) -> %d, %p\n", hSrcProc, hSrc, hDstProc, dwDesiredAccess,
7360	fInheritHandle, dwOptions, fRet, *phNew));
7361	return fRet;
7362	}
7363
7364
7365	/** Kernel32 - CloseHandle */
7366	static BOOL WINAPI kwSandbox_Kernel32_CloseHandle(HANDLE hObject)
7367	{
7368	BOOL fRet;
7369	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hObject);
7370	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread \|\| g_fCtrlC);
7371	if (idxHandle < g_Sandbox.cHandles)
7372	{
7373	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
7374	if (pHandle)
7375	{
7376	/* Prevent the closing of the standard output and error handles. */
7377	if ( pHandle->enmType != KWHANDLETYPE_OUTPUT_BUF
7378	\|\| idxHandle != KW_HANDLE_TO_INDEX(pHandle->hHandle))
7379	{
7380	fRet = CloseHandle(hObject);
7381	if (fRet)
7382	{
7383	PKWHANDLE pHandle = g_Sandbox.papHandles[idxHandle];
7384	g_Sandbox.papHandles[idxHandle] = NULL;
7385	g_Sandbox.cActiveHandles--;
7386	kHlpAssert(g_Sandbox.cActiveHandles >= g_Sandbox.cFixedHandles);
7387	if (--pHandle->cRefs == 0)
7388	{
7389	#ifdef WITH_TEMP_MEMORY_FILES
7390	if (pHandle->enmType == KWHANDLETYPE_TEMP_FILE)
7391	{
7392	kHlpAssert(pHandle->u.pTempFile->cActiveHandles > 0);
7393	pHandle->u.pTempFile->cActiveHandles--;
7394	}
7395	#endif
7396	kHlpFree(pHandle);
7397	KWFS_LOG(("CloseHandle(%p) -> TRUE [intercepted handle, freed]\n", hObject));
7398	}
7399	else
7400	KWFS_LOG(("CloseHandle(%p) -> TRUE [intercepted handle, not freed]\n", hObject));
7401	}
7402	else
7403	KWFS_LOG(("CloseHandle(%p) -> FALSE [intercepted handle] err=%u!\n", hObject, GetLastError()));
7404	}
7405	else
7406	{
7407	KWFS_LOG(("CloseHandle(%p) -> TRUE [intercepted handle] Ignored closing of std%s!\n",
7408	hObject, hObject == g_Sandbox.StdErr.hOutput ? "err" : "out"));
7409	fRet = TRUE;
7410	}
7411	return fRet;
7412	}
7413	}
7414
7415	fRet = CloseHandle(hObject);
7416	KWFS_LOG(("CloseHandle(%p) -> %d\n", hObject, fRet));
7417	return fRet;
7418	}
7419
7420
7421	/** Kernel32 - GetFileAttributesA. */
7422	static DWORD WINAPI kwSandbox_Kernel32_GetFileAttributesA(LPCSTR pszFilename)
7423	{
7424	DWORD fRet;
7425	const char *pszExt = kHlpGetExt(pszFilename);
7426	if (kwFsIsCacheableExtensionA(pszExt, K_TRUE /fAttrQuery/))
7427	{
7428	KFSLOOKUPERROR enmError;
7429	PKFSOBJ pFsObj;
7430	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7431
7432	pFsObj = kFsCacheLookupNoMissingA(g_pFsCache, pszFilename, &enmError);
7433	if (pFsObj)
7434	{
7435	kHlpAssert(pFsObj->fHaveStats);
7436	fRet = pFsObj->Stats.st_attribs;
7437	kFsCacheObjRelease(g_pFsCache, pFsObj);
7438	}
7439	else
7440	{
7441	SetLastError(kwFsLookupErrorToWindowsError(enmError));
7442	fRet = INVALID_FILE_ATTRIBUTES;
7443	}
7444
7445	KWFS_LOG(("GetFileAttributesA(%s) -> %#x [cached]\n", pszFilename, fRet));
7446	return fRet;
7447	}
7448
7449	fRet = GetFileAttributesA(pszFilename);
7450	KWFS_LOG(("GetFileAttributesA(%s) -> %#x\n", pszFilename, fRet));
7451	return fRet;
7452	}
7453
7454
7455	/** Kernel32 - GetFileAttributesW. */
7456	static DWORD WINAPI kwSandbox_Kernel32_GetFileAttributesW(LPCWSTR pwszFilename)
7457	{
7458	DWORD fRet;
7459	if (kwFsIsCacheablePathExtensionW(pwszFilename, K_TRUE /fAttrQuery/))
7460	{
7461	KFSLOOKUPERROR enmError;
7462	PKFSOBJ pFsObj;
7463	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7464
7465	pFsObj = kFsCacheLookupNoMissingW(g_pFsCache, pwszFilename, &enmError);
7466	if (pFsObj)
7467	{
7468	kHlpAssert(pFsObj->fHaveStats);
7469	fRet = pFsObj->Stats.st_attribs;
7470	kFsCacheObjRelease(g_pFsCache, pFsObj);
7471	}
7472	else
7473	{
7474	SetLastError(kwFsLookupErrorToWindowsError(enmError));
7475	fRet = INVALID_FILE_ATTRIBUTES;
7476	}
7477
7478	KWFS_LOG(("GetFileAttributesW(%ls) -> %#x [cached]\n", pwszFilename, fRet));
7479	return fRet;
7480	}
7481
7482	fRet = GetFileAttributesW(pwszFilename);
7483	KWFS_LOG(("GetFileAttributesW(%ls) -> %#x\n", pwszFilename, fRet));
7484	return fRet;
7485	}
7486
7487
7488	/** Kernel32 - GetShortPathNameW - c1[xx].dll of VS2010 does this to the
7489	* directory containing each include file. We cache the result to speed
7490	* things up a little. */
7491	static DWORD WINAPI kwSandbox_Kernel32_GetShortPathNameW(LPCWSTR pwszLongPath, LPWSTR pwszShortPath, DWORD cwcShortPath)
7492	{
7493	DWORD cwcRet;
7494	if (kwFsIsCacheablePathExtensionW(pwszLongPath, K_TRUE /fAttrQuery/))
7495	{
7496	KFSLOOKUPERROR enmError;
7497	PKFSOBJ pObj;
7498	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7499
7500	pObj = kFsCacheLookupW(g_pFsCache, pwszLongPath, &enmError);
7501	if (pObj)
7502	{
7503	if (pObj->bObjType != KFSOBJ_TYPE_MISSING)
7504	{
7505	if (kFsCacheObjGetFullShortPathW(pObj, pwszShortPath, cwcShortPath, '\\'))
7506	{
7507	cwcRet = (DWORD)kwUtf16Len(pwszShortPath);
7508
7509	/* Should preserve trailing slash on directory paths. */
7510	if (pObj->bObjType == KFSOBJ_TYPE_DIR)
7511	{
7512	if ( cwcRet + 1 < cwcShortPath
7513	&& pwszShortPath[cwcRet - 1] != '\\')
7514	{
7515	KSIZE cwcIn = kwUtf16Len(pwszLongPath);
7516	if ( cwcIn > 0
7517	&& (pwszLongPath[cwcIn - 1] == '\\' \|\| pwszLongPath[cwcIn - 1] == '/') )
7518	{
7519	pwszShortPath[cwcRet++] = '\\';
7520	pwszShortPath[cwcRet] = '\0';
7521	}
7522	}
7523	}
7524
7525	KWFS_LOG(("GetShortPathNameW(%ls) -> '%.ls' & %#x [cached]\n",
7526	pwszLongPath, K_MIN(cwcShortPath, cwcRet), K_MIN(cwcShortPath, cwcRet), pwszShortPath, cwcRet));
7527	kFsCacheObjRelease(g_pFsCache, pObj);
7528	return cwcRet;
7529	}
7530
7531	/* fall back for complicated cases. */
7532	}
7533	kFsCacheObjRelease(g_pFsCache, pObj);
7534	}
7535	}
7536	cwcRet = GetShortPathNameW(pwszLongPath, pwszShortPath, cwcShortPath);
7537	KWFS_LOG(("GetShortPathNameW(%ls) -> '%.ls' & %#x\n",
7538	pwszLongPath, K_MIN(cwcShortPath, cwcRet), K_MIN(cwcShortPath, cwcRet), pwszShortPath, cwcRet));
7539	return cwcRet;
7540	}
7541
7542
7543	#ifdef WITH_TEMP_MEMORY_FILES
7544	/** Kernel32 - DeleteFileW
7545	* Skip deleting the in-memory files. */
7546	static BOOL WINAPI kwSandbox_Kernel32_DeleteFileW(LPCWSTR pwszFilename)
7547	{
7548	BOOL fRc;
7549	if ( g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL
7550	&& kwFsIsClTempFileW(pwszFilename))
7551	{
7552	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
7553	KWFS_LOG(("DeleteFileW(%s) -> TRUE [temp]\n", pwszFilename));
7554	fRc = TRUE;
7555	}
7556	else
7557	{
7558	fRc = DeleteFileW(pwszFilename);
7559	KWFS_LOG(("DeleteFileW(%s) -> %d (%d)\n", pwszFilename, fRc, GetLastError()));
7560	}
7561	return fRc;
7562	}
7563	#endif /* WITH_TEMP_MEMORY_FILES */
7564
7565
7566
7567	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
7568
7569	/*
7570	*
7571	* Console output buffering.
7572	* Console output buffering.
7573	* Console output buffering.
7574	*
7575	*/
7576
7577
7578	/**
7579	* Write a wide char string to the console.
7580	*
7581	* @param pSandbox The sandbox which output buffer to flush.
7582	*/
7583	static void kwSandboxConsoleWriteIt(PKWSANDBOX pSandbox, wchar_t const *pwcBuf, KU32 cwcToWrite)
7584	{
7585	if (cwcToWrite > 0)
7586	{
7587	DWORD cwcWritten = 0;
7588	if (WriteConsoleW(pSandbox->Combined.hOutput, pwcBuf, cwcToWrite, &cwcWritten, NULL))
7589	{
7590	if (cwcWritten == cwcToWrite)
7591	{ /* likely */ }
7592	else
7593	{
7594	DWORD off = 0;
7595	do
7596	{
7597	off += cwcWritten;
7598	cwcWritten = 0;
7599	} while ( off < cwcToWrite
7600	&& WriteConsoleW(pSandbox->Combined.hOutput, &pwcBuf[off], cwcToWrite - off, &cwcWritten, NULL));
7601	kHlpAssert(off == cwcWritten);
7602	}
7603	}
7604	else
7605	kHlpAssertFailed();
7606	pSandbox->Combined.cFlushes++;
7607	}
7608	}
7609
7610
7611	/**
7612	* Flushes the combined console output buffer.
7613	*
7614	* @param pSandbox The sandbox which output buffer to flush.
7615	*/
7616	static void kwSandboxConsoleFlushCombined(PKWSANDBOX pSandbox)
7617	{
7618	if (pSandbox->Combined.cwcBuf > 0)
7619	{
7620	KWOUT_LOG(("kwSandboxConsoleFlushCombined: %u wchars\n", pSandbox->Combined.cwcBuf));
7621	kwSandboxConsoleWriteIt(pSandbox, pSandbox->Combined.wszBuf, pSandbox->Combined.cwcBuf);
7622	pSandbox->Combined.cwcBuf = 0;
7623	}
7624	}
7625
7626
7627	/**
7628	* For handling combined buffer overflow cases line by line.
7629	*
7630	* @param pSandbox The sandbox.
7631	* @param pwcBuf What to add to the combined buffer. Usually a
7632	* line, unless we're really low on buffer space.
7633	* @param cwcBuf The length of what to add.
7634	* @param fBrokenLine Whether this is a broken line.
7635	*/
7636	static void kwSandboxConsoleAddToCombined(PKWSANDBOX pSandbox, wchar_t const *pwcBuf, KU32 cwcBuf, KBOOL fBrokenLine)
7637	{
7638	if (fBrokenLine)
7639	kwSandboxConsoleFlushCombined(pSandbox);
7640	if (pSandbox->Combined.cwcBuf + cwcBuf > K_ELEMENTS(pSandbox->Combined.wszBuf))
7641	{
7642	kwSandboxConsoleFlushCombined(pSandbox);
7643	kwSandboxConsoleWriteIt(pSandbox, pwcBuf, cwcBuf);
7644	}
7645	else
7646	{
7647	kHlpMemCopy(&pSandbox->Combined.wszBuf[pSandbox->Combined.cwcBuf], pwcBuf, cwcBuf * sizeof(wchar_t));
7648	pSandbox->Combined.cwcBuf += cwcBuf;
7649	}
7650	}
7651
7652
7653	/**
7654	* Called to final flush a line buffer via the combined buffer (if applicable).
7655	*
7656	* @param pSandbox The sandbox.
7657	* @param pLineBuf The line buffer.
7658	* @param pszName The line buffer name (for logging)
7659	*/
7660	static void kwSandboxConsoleFinalFlushLineBuf(PKWSANDBOX pSandbox, PKWOUTPUTSTREAMBUF pLineBuf, const char *pszName)
7661	{
7662	if (pLineBuf->fIsConsole)
7663	{
7664	if (pLineBuf->u.Con.cwcBuf > 0)
7665	{
7666	KWOUT_LOG(("kwSandboxConsoleFinalFlushLineBuf: %s: %u wchars\n", pszName, pLineBuf->u.Con.cwcBuf));
7667
7668	if (pLineBuf->u.Con.cwcBuf < pLineBuf->u.Con.cwcBufAlloc)
7669	{
7670	pLineBuf->u.Con.pwcBuf[pLineBuf->u.Con.cwcBuf++] = '\n';
7671	kwSandboxConsoleAddToCombined(pSandbox, pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf, K_FALSE /fBrokenLine/);
7672	}
7673	else
7674	{
7675	kwSandboxConsoleAddToCombined(pSandbox, pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf, K_TRUE /fBrokenLine/);
7676	kwSandboxConsoleAddToCombined(pSandbox, L"\n", 1, K_TRUE /fBrokenLine/);
7677	}
7678	pLineBuf->u.Con.cwcBuf = 0;
7679	}
7680	}
7681	#ifdef WITH_STD_OUT_ERR_BUFFERING
7682	else if (pLineBuf->u.Fully.cchBuf > 0)
7683	{
7684	KWOUT_LOG(("kwSandboxConsoleFinalFlushLineBuf: %s: %u bytes\n", pszName, pLineBuf->u.Fully.cchBuf));
7685
7686	kwSandboxOutBufWriteIt(pLineBuf->hBackup, pLineBuf->u.Fully.pchBuf, pLineBuf->u.Fully.cchBuf);
7687	pLineBuf->u.Fully.cchBuf = 0;
7688	}
7689	#endif
7690	}
7691
7692
7693	/**
7694	* Called at the end of sandboxed execution to flush both stream buffers.
7695	*
7696	* @param pSandbox The sandbox.
7697	*/
7698	static void kwSandboxConsoleFlushAll(PKWSANDBOX pSandbox)
7699	{
7700	/*
7701	* First do the cl.exe source file supression trick, if applicable.
7702	* The output ends up on CONOUT$ if either StdOut or StdErr is a console
7703	* handle.
7704	*/
7705	if ( pSandbox->pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL
7706	&& pSandbox->Combined.cFlushes == 0)
7707	{
7708	if ( pSandbox->StdOut.fIsConsole
7709	\|\| pSandbox->StdErr.fIsConsole)
7710	{
7711	if ( pSandbox->Combined.cwcBuf >= 3
7712	&& (pSandbox->StdOut.fIsConsole ? pSandbox->StdOut.u.Con.cwcBuf : pSandbox->StdOut.u.Fully.cchBuf) == 0
7713	&& (pSandbox->StdErr.fIsConsole ? pSandbox->StdErr.u.Con.cwcBuf : pSandbox->StdErr.u.Fully.cchBuf) == 0 )
7714	{
7715	KI32 off = pSandbox->Combined.cwcBuf - 1;
7716	if (pSandbox->Combined.wszBuf[off] == '\n')
7717	{
7718	KBOOL fOk = K_TRUE;
7719	while (off-- > 0)
7720	{
7721	wchar_t const wc = pSandbox->Combined.wszBuf[off];
7722	if (iswalnum(wc) \|\| wc == '.' \|\| wc == ' ' \|\| wc == '_' \|\| wc == '-')
7723	{ /* likely */ }
7724	else
7725	{
7726	fOk = K_FALSE;
7727	break;
7728	}
7729	}
7730	if (fOk)
7731	{
7732	KWOUT_LOG(("kwSandboxConsoleFlushAll: Dropping '%.ls in combined console buffer\n",
7733	pSandbox->Combined.cwcBuf, pSandbox->Combined.cwcBuf, pSandbox->Combined.wszBuf));
7734	pSandbox->Combined.cwcBuf = 0;
7735	return;
7736	}
7737	}
7738	KWOUT_LOG(("kwSandboxConsoleFlushAll: Unable to drop '%.ls in combined console buffer\n",
7739	pSandbox->Combined.cwcBuf, pSandbox->Combined.cwcBuf, pSandbox->Combined.wszBuf));
7740	}
7741	}
7742	#ifdef WITH_STD_OUT_ERR_BUFFERING
7743	/*
7744	* Otherwise, it goes to standard output (redirected).
7745	*/
7746	else if ( pSandbox->StdErr.u.Fully.cchBuf == 0
7747	&& pSandbox->StdOut.u.Fully.cchBuf >= 3)
7748	{
7749	char const *pchBuf = pSandbox->StdOut.u.Fully.pchBuf;
7750	KI32 off = pSandbox->StdOut.u.Fully.cchBuf - 1;
7751	kHlpAssert(pSandbox->Combined.cFlushes == 0 && pSandbox->Combined.cwcBuf == 0); /* unused! */
7752
7753	if (pchBuf[off] == '\n')
7754	{
7755	KBOOL fOk = K_TRUE;
7756	if (pchBuf[off - 1] == '\r')
7757	off--;
7758	while (off-- > 0)
7759	{
7760	char const ch = pchBuf[off];
7761	if (isalnum(ch) \|\| ch == '.' \|\| ch == ' ' \|\| ch == '_' \|\| ch == '-')
7762	{ /* likely */ }
7763	else
7764	{
7765	fOk = K_FALSE;
7766	break;
7767	}
7768	}
7769	if (fOk)
7770	{
7771	KWOUT_LOG(("kwSandboxConsoleFlushAll: Dropping '%.s in stdout buffer\n",
7772	pSandbox->StdOut.u.Fully.cchBuf, pSandbox->StdOut.u.Fully.cchBuf, pchBuf));
7773	pSandbox->StdOut.u.Fully.cchBuf = 0;
7774	return;
7775	}
7776	}
7777	KWOUT_LOG(("kwSandboxConsoleFlushAll: Unable to drop '%.s in stdout buffer\n",
7778	pSandbox->StdOut.u.Fully.cchBuf, pSandbox->StdOut.u.Fully.cchBuf, pchBuf));
7779	}
7780	#endif
7781	}
7782
7783	/*
7784	* Flush the two line buffer, the the combined buffer.
7785	*/
7786	kwSandboxConsoleFinalFlushLineBuf(pSandbox, &pSandbox->StdErr, "StdErr");
7787	kwSandboxConsoleFinalFlushLineBuf(pSandbox, &pSandbox->StdOut, "StdOut");
7788	kwSandboxConsoleFlushCombined(pSandbox);
7789	}
7790
7791
7792	/**
7793	* Writes a string to the given output stream.
7794	*
7795	* @param pSandbox The sandbox.
7796	* @param pLineBuf The line buffer for the output stream.
7797	* @param pwcBuffer The buffer to write.
7798	* @param cwcToWrite The number of wchar_t's in the buffer.
7799	*/
7800	static void kwSandboxConsoleWriteW(PKWSANDBOX pSandbox, PKWOUTPUTSTREAMBUF pLineBuf, wchar_t const *pwcBuffer, KU32 cwcToWrite)
7801	{
7802	kHlpAssert(pLineBuf->fIsConsole);
7803	if (cwcToWrite > 0)
7804	{
7805	/*
7806	* First, find the start of the last incomplete line so we can figure
7807	* out how much line buffering we need to do.
7808	*/
7809	KU32 cchLastIncompleteLine;
7810	KU32 offLastIncompleteLine = cwcToWrite;
7811	while ( offLastIncompleteLine > 0
7812	&& pwcBuffer[offLastIncompleteLine - 1] != '\n')
7813	offLastIncompleteLine--;
7814	cchLastIncompleteLine = cwcToWrite - offLastIncompleteLine;
7815
7816	/* Was there anything to line buffer? */
7817	if (offLastIncompleteLine < cwcToWrite)
7818	{
7819	/* Need to grow the line buffer? */
7820	KU32 cwcNeeded = offLastIncompleteLine == 0
7821	? pLineBuf->u.Con.cwcBuf + cchLastIncompleteLine /* incomplete line, append to line buffer */
7822	: cchLastIncompleteLine; /* Only the final incomplete line (if any) goes to the line buffer. */
7823	if (cwcNeeded > pLineBuf->u.Con.cwcBufAlloc)
7824	{
7825	void *pvNew;
7826	KU32 cwcNew = !pLineBuf->u.Con.cwcBufAlloc ? 1024 : pLineBuf->u.Con.cwcBufAlloc * 2;
7827	while (cwcNew < cwcNeeded)
7828	cwcNew *= 2;
7829	pvNew = kHlpRealloc(pLineBuf->u.Con.pwcBuf, cwcNew * sizeof(wchar_t));
7830	if (pvNew)
7831	{
7832	pLineBuf->u.Con.pwcBuf = (wchar_t *)pvNew;
7833	pLineBuf->u.Con.cwcBufAlloc = cwcNew;
7834	}
7835	else
7836	{
7837	pvNew = kHlpRealloc(pLineBuf->u.Con.pwcBuf, cwcNeeded * sizeof(wchar_t));
7838	if (pvNew)
7839	{
7840	pLineBuf->u.Con.pwcBuf = (wchar_t *)pvNew;
7841	pLineBuf->u.Con.cwcBufAlloc = cwcNeeded;
7842	}
7843	else
7844	{
7845	/* This isn't perfect, but it will have to do for now. */
7846	if (pLineBuf->u.Con.cwcBuf > 0)
7847	{
7848	kwSandboxConsoleAddToCombined(pSandbox, pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf,
7849	K_TRUE /fBrokenLine/);
7850	pLineBuf->u.Con.cwcBuf = 0;
7851	}
7852	kwSandboxConsoleAddToCombined(pSandbox, pwcBuffer, cwcToWrite, K_TRUE /fBrokenLine/);
7853	return;
7854	}
7855	}
7856	}
7857
7858	/*
7859	* Handle the case where we only add to the line buffer.
7860	*/
7861	if (offLastIncompleteLine == 0)
7862	{
7863	kHlpMemCopy(&pLineBuf->u.Con.pwcBuf[pLineBuf->u.Con.cwcBuf], pwcBuffer, cwcToWrite * sizeof(wchar_t));
7864	pLineBuf->u.Con.cwcBuf += cwcToWrite;
7865	return;
7866	}
7867	}
7868
7869	/*
7870	* If there is sufficient combined buffer to handle this request, this is rather simple.
7871	*/
7872	kHlpAssert(pSandbox->Combined.cwcBuf <= K_ELEMENTS(pSandbox->Combined.wszBuf));
7873	if (pSandbox->Combined.cwcBuf + pLineBuf->u.Con.cwcBuf + offLastIncompleteLine <= K_ELEMENTS(pSandbox->Combined.wszBuf))
7874	{
7875	if (pLineBuf->u.Con.cwcBuf > 0)
7876	{
7877	kHlpMemCopy(&pSandbox->Combined.wszBuf[pSandbox->Combined.cwcBuf],
7878	pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf * sizeof(wchar_t));
7879	pSandbox->Combined.cwcBuf += pLineBuf->u.Con.cwcBuf;
7880	pLineBuf->u.Con.cwcBuf = 0;
7881	}
7882
7883	kHlpMemCopy(&pSandbox->Combined.wszBuf[pSandbox->Combined.cwcBuf],
7884	pwcBuffer, offLastIncompleteLine * sizeof(wchar_t));
7885	pSandbox->Combined.cwcBuf += offLastIncompleteLine;
7886	}
7887	else
7888	{
7889	/*
7890	* Do line-by-line processing of the input, flusing the combined buffer
7891	* when it becomes necessary. We may have to write lines
7892	*/
7893	KU32 off = 0;
7894	KU32 offNextLine = 0;
7895
7896	/* If there are buffered chars, we handle the first line outside the
7897	main loop. We must try our best outputting it as a complete line. */
7898	if (pLineBuf->u.Con.cwcBuf > 0)
7899	{
7900	while (offNextLine < cwcToWrite && pwcBuffer[offNextLine] != '\n')
7901	offNextLine++;
7902	offNextLine++;
7903	kHlpAssert(offNextLine <= offLastIncompleteLine);
7904
7905	if (pSandbox->Combined.cwcBuf + pLineBuf->u.Con.cwcBuf + offNextLine <= K_ELEMENTS(pSandbox->Combined.wszBuf))
7906	{
7907	kHlpMemCopy(&pSandbox->Combined.wszBuf[pSandbox->Combined.cwcBuf],
7908	pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf * sizeof(wchar_t));
7909	pSandbox->Combined.cwcBuf += pLineBuf->u.Con.cwcBuf;
7910	pLineBuf->u.Con.cwcBuf = 0;
7911
7912	kHlpMemCopy(&pSandbox->Combined.wszBuf[pSandbox->Combined.cwcBuf], pwcBuffer, offNextLine * sizeof(wchar_t));
7913	pSandbox->Combined.cwcBuf += offNextLine;
7914	}
7915	else
7916	{
7917	KU32 cwcLeft = pLineBuf->u.Con.cwcBufAlloc - pLineBuf->u.Con.cwcBuf;
7918	if (cwcLeft > 0)
7919	{
7920	KU32 cwcCopy = K_MIN(cwcLeft, offNextLine);
7921	kHlpMemCopy(&pLineBuf->u.Con.pwcBuf[pLineBuf->u.Con.cwcBuf], pwcBuffer, cwcCopy * sizeof(wchar_t));
7922	pLineBuf->u.Con.cwcBuf += cwcCopy;
7923	off += cwcCopy;
7924	}
7925	if (pLineBuf->u.Con.cwcBuf > 0)
7926	{
7927	kwSandboxConsoleAddToCombined(pSandbox, pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf,
7928	K_TRUE /fBrokenLine/);
7929	pLineBuf->u.Con.cwcBuf = 0;
7930	}
7931	if (off < offNextLine)
7932	kwSandboxConsoleAddToCombined(pSandbox, &pwcBuffer[off], offNextLine - off, K_TRUE /fBrokenLine/);
7933	}
7934	off = offNextLine;
7935	}
7936
7937	/* Deal with the remaining lines */
7938	while (off < offLastIncompleteLine)
7939	{
7940	while (offNextLine < offLastIncompleteLine && pwcBuffer[offNextLine] != '\n')
7941	offNextLine++;
7942	offNextLine++;
7943	kHlpAssert(offNextLine <= offLastIncompleteLine);
7944	kwSandboxConsoleAddToCombined(pSandbox, &pwcBuffer[off], offNextLine - off, K_FALSE /fBrokenLine/);
7945	off = offNextLine;
7946	}
7947	}
7948
7949	/*
7950	* Buffer any remaining incomplete line chars.
7951	*/
7952	if (cchLastIncompleteLine)
7953	{
7954	kHlpMemCopy(&pLineBuf->u.Con.pwcBuf[0], &pwcBuffer[offLastIncompleteLine], cchLastIncompleteLine * sizeof(wchar_t));
7955	pLineBuf->u.Con.cwcBuf = cchLastIncompleteLine;
7956	}
7957	}
7958	}
7959
7960
7961	/**
7962	* Worker for WriteConsoleA and WriteFile.
7963	*
7964	* @param pSandbox The sandbox.
7965	* @param pLineBuf The line buffer.
7966	* @param pchBuffer What to write.
7967	* @param cchToWrite How much to write.
7968	*/
7969	static void kwSandboxConsoleWriteA(PKWSANDBOX pSandbox, PKWOUTPUTSTREAMBUF pLineBuf, const char *pchBuffer, KU32 cchToWrite)
7970	{
7971	/*
7972	* Convert it to wide char and use the 'W' to do the work.
7973	*/
7974	int cwcRet;
7975	KU32 cwcBuf = cchToWrite * 2 + 1;
7976	wchar_t *pwcBufFree = NULL;
7977	wchar_t *pwcBuf;
7978	kHlpAssert(pLineBuf->fIsConsole);
7979
7980	if (cwcBuf <= 4096)
7981	pwcBuf = alloca(cwcBuf * sizeof(wchar_t));
7982	else
7983	pwcBuf = pwcBufFree = kHlpAlloc(cwcBuf * sizeof(wchar_t));
7984
7985	cwcRet = MultiByteToWideChar(pSandbox->Combined.uCodepage, 0/dwFlags/, pchBuffer, cchToWrite, pwcBuf, cwcBuf);
7986	if (cwcRet > 0)
7987	kwSandboxConsoleWriteW(pSandbox, pLineBuf, pwcBuf, cwcRet);
7988	else
7989	{
7990	DWORD cchWritten;
7991	kHlpAssertFailed();
7992
7993	/* Flush the line buffer and combined buffer before calling WriteConsoleA. */
7994	if (pLineBuf->u.Con.cwcBuf > 0)
7995	{
7996	kwSandboxConsoleAddToCombined(pSandbox, pLineBuf->u.Con.pwcBuf, pLineBuf->u.Con.cwcBuf, K_TRUE /fBroken/);
7997	pLineBuf->u.Con.cwcBuf = 0;
7998	}
7999	kwSandboxConsoleFlushCombined(pSandbox);
8000
8001	if (WriteConsoleA(pLineBuf->hBackup, pchBuffer, cchToWrite, &cchWritten, NULL /pvReserved/))
8002	{
8003	if (cchWritten >= cchToWrite)
8004	{ /* likely */ }
8005	else
8006	{
8007	KU32 off = 0;
8008	do
8009	{
8010	off += cchWritten;
8011	cchWritten = 0;
8012	} while ( off < cchToWrite
8013	&& WriteConsoleA(pLineBuf->hBackup, &pchBuffer[off], cchToWrite - off, &cchWritten, NULL));
8014	}
8015	}
8016	}
8017
8018	if (pwcBufFree)
8019	kHlpFree(pwcBufFree);
8020	}
8021
8022
8023	/** Kernel32 - WriteConsoleA */
8024	BOOL WINAPI kwSandbox_Kernel32_WriteConsoleA(HANDLE hConOutput, CONST VOID *pvBuffer, DWORD cbToWrite, PDWORD pcbWritten,
8025	PVOID pvReserved)
8026	{
8027	BOOL fRc;
8028	PKWOUTPUTSTREAMBUF pLineBuf;
8029	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8030
8031	if (hConOutput == g_Sandbox.StdErr.hOutput)
8032	pLineBuf = &g_Sandbox.StdErr;
8033	else
8034	pLineBuf = &g_Sandbox.StdOut;
8035	if (pLineBuf->fIsConsole)
8036	{
8037	kwSandboxConsoleWriteA(&g_Sandbox, pLineBuf, (char const *)pvBuffer, cbToWrite);
8038
8039	KWOUT_LOG(("WriteConsoleA: %p, %p LB %#x (%.s), %p, %p -> TRUE [cached]\n",
8040	hConOutput, pvBuffer, cbToWrite, cbToWrite, cbToWrite, pvBuffer, pcbWritten, pvReserved));
8041	if (pcbWritten)
8042	*pcbWritten = cbToWrite;
8043	fRc = TRUE;
8044	}
8045	else
8046	{
8047	fRc = WriteConsoleA(hConOutput, pvBuffer, cbToWrite, pcbWritten, pvReserved);
8048	KWOUT_LOG(("WriteConsoleA: %p, %p LB %#x (%.s), %p, %p -> %d !fallback!\n",
8049	hConOutput, pvBuffer, cbToWrite, cbToWrite, cbToWrite, pvBuffer, pcbWritten, pvReserved, fRc));
8050	}
8051	return fRc;
8052	}
8053
8054
8055	/** Kernel32 - WriteConsoleW */
8056	BOOL WINAPI kwSandbox_Kernel32_WriteConsoleW(HANDLE hConOutput, CONST VOID *pvBuffer, DWORD cwcToWrite, PDWORD pcwcWritten,
8057	PVOID pvReserved)
8058	{
8059	BOOL fRc;
8060	PKWOUTPUTSTREAMBUF pLineBuf;
8061	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8062
8063	if (hConOutput == g_Sandbox.StdErr.hOutput)
8064	pLineBuf = &g_Sandbox.StdErr;
8065	else if (hConOutput == g_Sandbox.StdOut.hOutput)
8066	pLineBuf = &g_Sandbox.StdOut;
8067	else
8068	pLineBuf = g_Sandbox.StdErr.fIsConsole ? &g_Sandbox.StdErr : &g_Sandbox.StdOut;
8069	if (pLineBuf->fIsConsole)
8070	{
8071	kwSandboxConsoleWriteW(&g_Sandbox, pLineBuf, (wchar_t const *)pvBuffer, cwcToWrite);
8072
8073	KWOUT_LOG(("WriteConsoleW: %p, %p LB %#x (%.ls), %p, %p -> TRUE [cached]\n",
8074	hConOutput, pvBuffer, cwcToWrite, cwcToWrite, cwcToWrite, pvBuffer, pcwcWritten, pvReserved));
8075	if (pcwcWritten)
8076	*pcwcWritten = cwcToWrite;
8077	fRc = TRUE;
8078	}
8079	else
8080	{
8081	fRc = WriteConsoleW(hConOutput, pvBuffer, cwcToWrite, pcwcWritten, pvReserved);
8082	KWOUT_LOG(("WriteConsoleW: %p, %p LB %#x (%.ls), %p, %p -> %d !fallback!\n",
8083	hConOutput, pvBuffer, cwcToWrite, cwcToWrite, cwcToWrite, pvBuffer, pcwcWritten, pvReserved, fRc));
8084	}
8085	return fRc;
8086	}
8087
8088	#endif /* WITH_CONSOLE_OUTPUT_BUFFERING */
8089
8090
8091
8092	/*
8093	*
8094	* Virtual memory leak prevension.
8095	* Virtual memory leak prevension.
8096	* Virtual memory leak prevension.
8097	*
8098	*/
8099
8100	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
8101
8102	/** For debug logging. */
8103	# ifndef NDEBUG
8104	static void kwSandboxLogFixedAllocation(KU32 idxFixed, const char *pszWhere)
8105	{
8106	MEMORY_BASIC_INFORMATION MemInfo = { NULL, NULL, 0, 0, 0, 0, 0};
8107	SIZE_T cbMemInfo = VirtualQuery(g_aFixedVirtualAllocs[idxFixed].pvReserved, &MemInfo, sizeof(MemInfo));
8108	kHlpAssert(cbMemInfo == sizeof(MemInfo));
8109	if (cbMemInfo != 0)
8110	KW_LOG(("%s: #%u %p LB %#x: base=%p alloc=%p region=%#x state=%#x prot=%#x type=%#x\n",
8111	pszWhere, idxFixed, g_aFixedVirtualAllocs[idxFixed].pvReserved, g_aFixedVirtualAllocs[idxFixed].cbFixed,
8112	MemInfo.BaseAddress,
8113	MemInfo.AllocationBase,
8114	MemInfo.RegionSize,
8115	MemInfo.State,
8116	MemInfo.Protect,
8117	MemInfo.Type));
8118	}
8119	# else
8120	# define kwSandboxLogFixedAllocation(idxFixed, pszWhere) do { } while (0)
8121	# endif
8122
8123	/**
8124	* Used by both kwSandbox_Kernel32_VirtualFree and kwSandboxCleanupLate
8125	*
8126	* @param idxFixed The fixed allocation index to "free".
8127	*/
8128	static void kwSandboxResetFixedAllocation(KU32 idxFixed)
8129	{
8130	BOOL fRc;
8131	kwSandboxLogFixedAllocation(idxFixed, "kwSandboxResetFixedAllocation[pre]");
8132	fRc = VirtualFree(g_aFixedVirtualAllocs[idxFixed].pvReserved, g_aFixedVirtualAllocs[idxFixed].cbFixed, MEM_DECOMMIT);
8133	kHlpAssert(fRc); K_NOREF(fRc);
8134	kwSandboxLogFixedAllocation(idxFixed, "kwSandboxResetFixedAllocation[pst]");
8135	g_aFixedVirtualAllocs[idxFixed].fInUse = K_FALSE;
8136	}
8137
8138	#endif /* WITH_FIXED_VIRTUAL_ALLOCS */
8139
8140
8141	/** Kernel32 - VirtualAlloc - for managing cl.exe / c1[xx].dll heap with fixed
8142	* location (~78MB in 32-bit 2010 compiler). */
8143	static PVOID WINAPI kwSandbox_Kernel32_VirtualAlloc(PVOID pvAddr, SIZE_T cb, DWORD fAllocType, DWORD fProt)
8144	{
8145	PVOID pvMem;
8146	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL)
8147	{
8148	KU32 idxPreAllocated = KU32_MAX;
8149
8150	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
8151	/*
8152	* Look for a pre-reserved CL.exe heap allocation.
8153	*/
8154	pvMem = NULL;
8155	if ( pvAddr != 0
8156	&& (fAllocType & MEM_RESERVE))
8157	{
8158	KU32 idxFixed = K_ELEMENTS(g_aFixedVirtualAllocs);
8159	kHlpAssert(!(fAllocType & ~(MEM_RESERVE \| MEM_TOP_DOWN)));
8160	while (idxFixed-- > 0)
8161	if ( g_aFixedVirtualAllocs[idxFixed].uFixed == (KUPTR)pvAddr
8162	&& g_aFixedVirtualAllocs[idxFixed].pvReserved)
8163	{
8164	if (g_aFixedVirtualAllocs[idxFixed].cbFixed >= cb)
8165	{
8166	if (!g_aFixedVirtualAllocs[idxFixed].fInUse)
8167	{
8168	g_aFixedVirtualAllocs[idxFixed].fInUse = K_TRUE;
8169	pvMem = pvAddr;
8170	idxPreAllocated = idxFixed;
8171	KW_LOG(("VirtualAlloc: pvAddr=%p cb=%p type=%#x prot=%#x -> %p [pre allocated]\n",
8172	pvAddr, cb, fAllocType, fProt, pvMem));
8173	kwSandboxLogFixedAllocation(idxFixed, "kwSandbox_Kernel32_VirtualAlloc");
8174	SetLastError(NO_ERROR);
8175	break;
8176	}
8177	kwErrPrintf("VirtualAlloc: Fixed allocation at %p is already in use!\n", pvAddr);
8178	}
8179	else
8180	kwErrPrintf("VirtualAlloc: Fixed allocation at %p LB %#x not large enough: %#x\n",
8181	pvAddr, g_aFixedVirtualAllocs[idxFixed].cbFixed, cb);
8182	}
8183	}
8184	if (!pvMem)
8185	#endif
8186	{
8187	pvMem = VirtualAlloc(pvAddr, cb, fAllocType, fProt);
8188	KW_LOG(("VirtualAlloc: pvAddr=%p cb=%p type=%#x prot=%#x -> %p (last=%d)\n",
8189	pvAddr, cb, fAllocType, fProt, pvMem, GetLastError()));
8190	if (pvAddr && pvAddr != pvMem)
8191	kwErrPrintf("VirtualAlloc %p LB %#x (%#x,%#x) failed: %p / %u\n",
8192	pvAddr, cb, fAllocType, fProt, pvMem, GetLastError());
8193	}
8194
8195	if (pvMem)
8196	{
8197	/*
8198	* Track it.
8199	*/
8200	PKWVIRTALLOC pTracker;
8201	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8202
8203	pTracker = g_Sandbox.pVirtualAllocHead;
8204	while ( pTracker
8205	&& (KUPTR)pvMem - (KUPTR)pTracker->pvAlloc >= pTracker->cbAlloc)
8206	pTracker = pTracker->pNext;
8207	if (!pTracker)
8208	{
8209	DWORD dwErr = GetLastError();
8210	PKWVIRTALLOC pTracker = (PKWVIRTALLOC)kHlpAlloc(sizeof(*pTracker));
8211	if (pTracker)
8212	{
8213	pTracker->pvAlloc = pvMem;
8214	pTracker->cbAlloc = cb;
8215	pTracker->idxPreAllocated = idxPreAllocated;
8216	pTracker->pNext = g_Sandbox.pVirtualAllocHead;
8217	g_Sandbox.pVirtualAllocHead = pTracker;
8218	}
8219	SetLastError(dwErr);
8220	}
8221	}
8222	}
8223	else
8224	pvMem = VirtualAlloc(pvAddr, cb, fAllocType, fProt);
8225	KW_LOG(("VirtualAlloc: pvAddr=%p cb=%p type=%#x prot=%#x -> %p (last=%d)\n",
8226	pvAddr, cb, fAllocType, fProt, pvMem, GetLastError()));
8227	return pvMem;
8228	}
8229
8230
8231	/** Kernel32 - VirtualFree. */
8232	static BOOL WINAPI kwSandbox_Kernel32_VirtualFree(PVOID pvAddr, SIZE_T cb, DWORD dwFreeType)
8233	{
8234	BOOL fRc;
8235	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL)
8236	{
8237	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8238	if (dwFreeType & MEM_RELEASE)
8239	{
8240	PKWVIRTALLOC pTracker = g_Sandbox.pVirtualAllocHead;
8241	if (pTracker)
8242	{
8243	if (pTracker->pvAlloc == pvAddr)
8244	g_Sandbox.pVirtualAllocHead = pTracker->pNext;
8245	else
8246	{
8247	PKWVIRTALLOC pPrev;
8248	do
8249	{
8250	pPrev = pTracker;
8251	pTracker = pTracker->pNext;
8252	} while (pTracker && pTracker->pvAlloc != pvAddr);
8253	if (pTracker)
8254	pPrev->pNext = pTracker->pNext;
8255	}
8256	if (pTracker)
8257	{
8258	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
8259	if (pTracker->idxPreAllocated != KU32_MAX)
8260	{
8261	kwSandboxResetFixedAllocation(pTracker->idxPreAllocated);
8262	KW_LOG(("VirtualFree: pvAddr=%p cb=%p type=%#x -> TRUE [pre allocated #%u]\n",
8263	pvAddr, cb, dwFreeType, pTracker->idxPreAllocated));
8264	kHlpFree(pTracker);
8265	return TRUE;
8266	}
8267	#endif
8268
8269	fRc = VirtualFree(pvAddr, cb, dwFreeType);
8270	if (fRc)
8271	kHlpFree(pTracker);
8272	else
8273	{
8274	pTracker->pNext = g_Sandbox.pVirtualAllocHead;
8275	g_Sandbox.pVirtualAllocHead = pTracker;
8276	}
8277	KW_LOG(("VirtualFree: pvAddr=%p cb=%p type=%#x -> %d\n", pvAddr, cb, dwFreeType, fRc));
8278	return fRc;
8279	}
8280
8281	KW_LOG(("VirtualFree: pvAddr=%p not found!\n", pvAddr));
8282	}
8283	}
8284	}
8285
8286	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
8287	/*
8288	* Protect our fixed allocations (this isn't just paranoia, btw.).
8289	*/
8290	if (dwFreeType & MEM_RELEASE)
8291	{
8292	KU32 idxFixed = K_ELEMENTS(g_aFixedVirtualAllocs);
8293	while (idxFixed-- > 0)
8294	if (g_aFixedVirtualAllocs[idxFixed].pvReserved == pvAddr)
8295	{
8296	KW_LOG(("VirtualFree: Damn it! Don't free g_aFixedVirtualAllocs[#%u]: %p LB %#x\n",
8297	idxFixed, g_aFixedVirtualAllocs[idxFixed].pvReserved, g_aFixedVirtualAllocs[idxFixed].cbFixed));
8298	return TRUE;
8299	}
8300	}
8301	#endif
8302
8303	/*
8304	* Not tracker or not actually free the virtual range.
8305	*/
8306	fRc = VirtualFree(pvAddr, cb, dwFreeType);
8307	KW_LOG(("VirtualFree: pvAddr=%p cb=%p type=%#x -> %d\n", pvAddr, cb, dwFreeType, fRc));
8308	return fRc;
8309	}
8310
8311
8312	/** Kernel32 - HeapCreate / NtDll - RTlCreateHeap */
8313	HANDLE WINAPI kwSandbox_Kernel32_HeapCreate(DWORD fOptions, SIZE_T cbInitial, SIZE_T cbMax)
8314	{
8315	HANDLE hHeap;
8316	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8317
8318	hHeap = HeapCreate(fOptions, cbInitial, cbMax);
8319	if (hHeap != NULL)
8320	{
8321	DWORD dwErr = GetLastError();
8322	PKWHEAP pTracker = (PKWHEAP)kHlpAlloc(sizeof(*pTracker));
8323	if (pTracker)
8324	{
8325	pTracker->hHeap = hHeap;
8326	pTracker->pNext = g_Sandbox.pHeapHead;
8327	g_Sandbox.pHeapHead = pTracker;
8328	}
8329
8330	SetLastError(dwErr);
8331	}
8332	return hHeap;
8333
8334	}
8335
8336
8337	/** Kernel32 - HeapDestroy / NtDll - RTlDestroyHeap */
8338	BOOL WINAPI kwSandbox_Kernel32_HeapDestroy(HANDLE hHeap)
8339	{
8340	BOOL fRc = HeapDestroy(hHeap);
8341	KW_LOG(("HeapDestroy: hHeap=%p -> %d\n", hHeap, fRc));
8342	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8343	if (fRc)
8344	{
8345	PKWHEAP pTracker = g_Sandbox.pHeapHead;
8346	if (pTracker)
8347	{
8348	if (pTracker->hHeap == hHeap)
8349	g_Sandbox.pHeapHead = pTracker->pNext;
8350	else
8351	{
8352	PKWHEAP pPrev;
8353	do
8354	{
8355	pPrev = pTracker;
8356	pTracker = pTracker->pNext;
8357	} while (pTracker && pTracker->hHeap == hHeap);
8358	if (pTracker)
8359	pPrev->pNext = pTracker->pNext;
8360	}
8361	if (pTracker)
8362	kHlpFree(pTracker);
8363	else
8364	KW_LOG(("HeapDestroy: pvAddr=%p not found!\n", hHeap));
8365	}
8366	}
8367
8368	return fRc;
8369	}
8370
8371
8372
8373	/*
8374	*
8375	* Thread/Fiber local storage leak prevention.
8376	* Thread/Fiber local storage leak prevention.
8377	* Thread/Fiber local storage leak prevention.
8378	*
8379	* Note! The FlsAlloc/Free & TlsAlloc/Free causes problems for statically
8380	* linked VS2010 code like VBoxBs3ObjConverter.exe. One thing is that
8381	* we're leaking these indexes, but more importantely we crash during
8382	* worker exit since the callback is triggered multiple times.
8383	*/
8384
8385
8386	/** Kernel32 - FlsAlloc */
8387	DWORD WINAPI kwSandbox_Kernel32_FlsAlloc(PFLS_CALLBACK_FUNCTION pfnCallback)
8388	{
8389	DWORD idxFls = FlsAlloc(pfnCallback);
8390	KW_LOG(("FlsAlloc(%p) -> %#x\n", pfnCallback, idxFls));
8391	if (idxFls != FLS_OUT_OF_INDEXES)
8392	{
8393	PKWLOCALSTORAGE pTracker = (PKWLOCALSTORAGE)kHlpAlloc(sizeof(*pTracker));
8394	if (pTracker)
8395	{
8396	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8397	pTracker->idx = idxFls;
8398	pTracker->pNext = g_Sandbox.pFlsAllocHead;
8399	g_Sandbox.pFlsAllocHead = pTracker;
8400	}
8401	}
8402
8403	return idxFls;
8404	}
8405
8406	/** Kernel32 - FlsFree */
8407	BOOL WINAPI kwSandbox_Kernel32_FlsFree(DWORD idxFls)
8408	{
8409	BOOL fRc = FlsFree(idxFls);
8410	KW_LOG(("FlsFree(%#x) -> %d\n", idxFls, fRc));
8411	if (fRc)
8412	{
8413	PKWLOCALSTORAGE pTracker;
8414	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8415
8416	pTracker = g_Sandbox.pFlsAllocHead;
8417	if (pTracker)
8418	{
8419	if (pTracker->idx == idxFls)
8420	g_Sandbox.pFlsAllocHead = pTracker->pNext;
8421	else
8422	{
8423	PKWLOCALSTORAGE pPrev;
8424	do
8425	{
8426	pPrev = pTracker;
8427	pTracker = pTracker->pNext;
8428	} while (pTracker && pTracker->idx != idxFls);
8429	if (pTracker)
8430	pPrev->pNext = pTracker->pNext;
8431	}
8432	if (pTracker)
8433	{
8434	pTracker->idx = FLS_OUT_OF_INDEXES;
8435	pTracker->pNext = NULL;
8436	kHlpFree(pTracker);
8437	}
8438	}
8439	}
8440	return fRc;
8441	}
8442
8443
8444	/** Kernel32 - TlsAlloc */
8445	DWORD WINAPI kwSandbox_Kernel32_TlsAlloc(VOID)
8446	{
8447	DWORD idxTls = TlsAlloc();
8448	KW_LOG(("TlsAlloc() -> %#x\n", idxTls));
8449	if (idxTls != TLS_OUT_OF_INDEXES)
8450	{
8451	PKWLOCALSTORAGE pTracker = (PKWLOCALSTORAGE)kHlpAlloc(sizeof(*pTracker));
8452	if (pTracker)
8453	{
8454	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8455	pTracker->idx = idxTls;
8456	pTracker->pNext = g_Sandbox.pTlsAllocHead;
8457	g_Sandbox.pTlsAllocHead = pTracker;
8458	}
8459	}
8460
8461	return idxTls;
8462	}
8463
8464	/** Kernel32 - TlsFree */
8465	BOOL WINAPI kwSandbox_Kernel32_TlsFree(DWORD idxTls)
8466	{
8467	BOOL fRc = TlsFree(idxTls);
8468	KW_LOG(("TlsFree(%#x) -> %d\n", idxTls, fRc));
8469	if (fRc)
8470	{
8471	PKWLOCALSTORAGE pTracker;
8472	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8473
8474	pTracker = g_Sandbox.pTlsAllocHead;
8475	if (pTracker)
8476	{
8477	if (pTracker->idx == idxTls)
8478	g_Sandbox.pTlsAllocHead = pTracker->pNext;
8479	else
8480	{
8481	PKWLOCALSTORAGE pPrev;
8482	do
8483	{
8484	pPrev = pTracker;
8485	pTracker = pTracker->pNext;
8486	} while (pTracker && pTracker->idx != idxTls);
8487	if (pTracker)
8488	pPrev->pNext = pTracker->pNext;
8489	}
8490	if (pTracker)
8491	{
8492	pTracker->idx = TLS_OUT_OF_INDEXES;
8493	pTracker->pNext = NULL;
8494	kHlpFree(pTracker);
8495	}
8496	}
8497	}
8498	return fRc;
8499	}
8500
8501
8502
8503	/*
8504	*
8505	* Header file hashing.
8506	* Header file hashing.
8507	* Header file hashing.
8508	*
8509	* c1.dll / c1XX.dll hashes the input files. The Visual C++ 2010 profiler
8510	* indicated that ~12% of the time was spent doing MD5 caluclation when
8511	* rebuiling openssl. The hashing it done right after reading the source
8512	* via ReadFile, same buffers and sizes.
8513	*/
8514
8515	#ifdef WITH_HASH_MD5_CACHE
8516
8517	/** AdvApi32 - CryptCreateHash */
8518	static BOOL WINAPI kwSandbox_Advapi32_CryptCreateHash(HCRYPTPROV hProv, ALG_ID idAlg, HCRYPTKEY hKey, DWORD dwFlags,
8519	HCRYPTHASH *phHash)
8520	{
8521	BOOL fRc;
8522
8523	/*
8524	* Only do this for cl.exe when it request normal MD5.
8525	*/
8526	if (g_Sandbox.pTool->u.Sandboxed.enmHint == KWTOOLHINT_VISUAL_CPP_CL)
8527	{
8528	if (idAlg == CALG_MD5)
8529	{
8530	if (hKey == 0)
8531	{
8532	if (dwFlags == 0)
8533	{
8534	PKWHASHMD5 pHash = (PKWHASHMD5)kHlpAllocZ(sizeof(*pHash));
8535	if (pHash)
8536	{
8537	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8538	pHash->uMagic = KWHASHMD5_MAGIC;
8539	pHash->cbHashed = 0;
8540	pHash->fGoneBad = K_FALSE;
8541	pHash->fFallbackMode = K_FALSE;
8542	pHash->fFinal = K_FALSE;
8543
8544	/* link it. */
8545	pHash->pNext = g_Sandbox.pHashHead;
8546	g_Sandbox.pHashHead = pHash;
8547
8548	*phHash = (KUPTR)pHash;
8549	KWCRYPT_LOG(("CryptCreateHash(hProv=%p, idAlg=CALG_MD5, 0, 0, *phHash=%p) -> %d [cached]\n",
8550	hProv, *phHash, TRUE));
8551	return TRUE;
8552	}
8553
8554	kwErrPrintf("CryptCreateHash: out of memory!\n");
8555	}
8556	else
8557	kwErrPrintf("CryptCreateHash: dwFlags=%p is not supported with CALG_MD5\n", hKey);
8558	}
8559	else
8560	kwErrPrintf("CryptCreateHash: hKey=%p is not supported with CALG_MD5\n", hKey);
8561	}
8562	else
8563	kwErrPrintf("CryptCreateHash: idAlg=%#x is not supported\n", idAlg);
8564	}
8565
8566	/*
8567	* Fallback.
8568	*/
8569	fRc = CryptCreateHash(hProv, idAlg, hKey, dwFlags, phHash);
8570	KWCRYPT_LOG(("CryptCreateHash(hProv=%p, idAlg=%#x (%d), hKey=%p, dwFlags=%#x, *phHash=%p) -> %d\n",
8571	hProv, idAlg, idAlg, hKey, dwFlags, *phHash, fRc));
8572	return fRc;
8573	}
8574
8575
8576	/** AdvApi32 - CryptHashData */
8577	static BOOL WINAPI kwSandbox_Advapi32_CryptHashData(HCRYPTHASH hHash, CONST BYTE *pbData, DWORD cbData, DWORD dwFlags)
8578	{
8579	BOOL fRc;
8580	PKWHASHMD5 pHash = g_Sandbox.pHashHead;
8581	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8582	while (pHash && (KUPTR)pHash != hHash)
8583	pHash = pHash->pNext;
8584	KWCRYPT_LOG(("CryptHashData(hHash=%p/%p, pbData=%p, cbData=%#x, dwFlags=%#x)\n",
8585	hHash, pHash, pbData, cbData, dwFlags));
8586	if (pHash)
8587	{
8588	/*
8589	* Validate the state.
8590	*/
8591	if ( pHash->uMagic == KWHASHMD5_MAGIC
8592	&& !pHash->fFinal)
8593	{
8594	if (!pHash->fFallbackMode)
8595	{
8596	/*
8597	* Does this match the previous ReadFile call to a cached file?
8598	* If it doesn't, try falling back.
8599	*/
8600	if ( g_Sandbox.LastHashRead.cbRead == cbData
8601	&& g_Sandbox.LastHashRead.pvRead == (void *)pbData)
8602	{
8603	PKFSWCACHEDFILE pCachedFile = g_Sandbox.LastHashRead.pCachedFile;
8604	if ( pCachedFile
8605	&& kHlpMemComp(pbData, &pCachedFile->pbCached[g_Sandbox.LastHashRead.offRead], K_MIN(cbData, 64)) == 0)
8606	{
8607
8608	if (g_Sandbox.LastHashRead.offRead == pHash->cbHashed)
8609	{
8610	if ( pHash->pCachedFile == NULL
8611	&& pHash->cbHashed == 0)
8612	pHash->pCachedFile = pCachedFile;
8613	if (pHash->pCachedFile == pCachedFile)
8614	{
8615	pHash->cbHashed += cbData;
8616	g_Sandbox.LastHashRead.pCachedFile = NULL;
8617	g_Sandbox.LastHashRead.pvRead = NULL;
8618	g_Sandbox.LastHashRead.cbRead = 0;
8619	g_Sandbox.LastHashRead.offRead = 0;
8620	KWCRYPT_LOG(("CryptHashData(hHash=%p/%p/%s, pbData=%p, cbData=%#x, dwFlags=%#x) -> 1 [cached]\n",
8621	hHash, pCachedFile, pCachedFile->szPath, pbData, cbData, dwFlags));
8622	return TRUE;
8623	}
8624
8625	/* Note! it's possible to fall back here too, if necessary. */
8626	kwErrPrintf("CryptHashData: Expected pCachedFile=%p, last read was made to %p!!\n",
8627	pHash->pCachedFile, g_Sandbox.LastHashRead.pCachedFile);
8628	}
8629	else
8630	kwErrPrintf("CryptHashData: Expected last read at %#x, instead it was made at %#x\n",
8631	pHash->cbHashed, g_Sandbox.LastHashRead.offRead);
8632	}
8633	else if (!pCachedFile)
8634	kwErrPrintf("CryptHashData: Last pCachedFile is NULL when buffer address and size matches!\n");
8635	else
8636	kwErrPrintf("CryptHashData: First 64 bytes of the buffer doesn't match the cache.\n");
8637	}
8638	else if (g_Sandbox.LastHashRead.cbRead != 0 && pHash->cbHashed != 0)
8639	kwErrPrintf("CryptHashData: Expected cbRead=%#x and pbData=%p, got %#x and %p instead\n",
8640	g_Sandbox.LastHashRead.cbRead, g_Sandbox.LastHashRead.pvRead, cbData, pbData);
8641	if (pHash->cbHashed == 0)
8642	pHash->fFallbackMode = K_TRUE;
8643	if (pHash->fFallbackMode)
8644	{
8645	/* Initiate fallback mode (file that we don't normally cache, like .c/.cpp). */
8646	pHash->fFallbackMode = K_TRUE;
8647	MD5Init(&pHash->Md5Ctx);
8648	MD5Update(&pHash->Md5Ctx, pbData, cbData);
8649	pHash->cbHashed = cbData;
8650	KWCRYPT_LOG(("CryptHashData(hHash=%p/fallback, pbData=%p, cbData=%#x, dwFlags=%#x) -> 1 [fallback!]\n",
8651	hHash, pbData, cbData, dwFlags));
8652	return TRUE;
8653	}
8654	pHash->fGoneBad = K_TRUE;
8655	SetLastError(ERROR_INVALID_PARAMETER);
8656	fRc = FALSE;
8657	}
8658	else
8659	{
8660	/* fallback. */
8661	MD5Update(&pHash->Md5Ctx, pbData, cbData);
8662	pHash->cbHashed += cbData;
8663	fRc = TRUE;
8664	KWCRYPT_LOG(("CryptHashData(hHash=%p/fallback, pbData=%p, cbData=%#x, dwFlags=%#x) -> 1 [fallback]\n",
8665	hHash, pbData, cbData, dwFlags));
8666	}
8667	}
8668	/*
8669	* Bad handle state.
8670	*/
8671	else
8672	{
8673	if (pHash->uMagic != KWHASHMD5_MAGIC)
8674	kwErrPrintf("CryptHashData: Invalid cached hash handle!!\n");
8675	else
8676	kwErrPrintf("CryptHashData: Hash is already finalized!!\n");
8677	SetLastError(NTE_BAD_HASH);
8678	fRc = FALSE;
8679	}
8680	}
8681	else
8682	{
8683
8684	fRc = CryptHashData(hHash, pbData, cbData, dwFlags);
8685	KWCRYPT_LOG(("CryptHashData(hHash=%p, pbData=%p, cbData=%#x, dwFlags=%#x) -> %d\n", hHash, pbData, cbData, dwFlags, fRc));
8686	}
8687	return fRc;
8688	}
8689
8690
8691	/** AdvApi32 - CryptGetHashParam */
8692	static BOOL WINAPI kwSandbox_Advapi32_CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam,
8693	BYTE pbData, DWORD pcbData, DWORD dwFlags)
8694	{
8695	BOOL fRc;
8696	PKWHASHMD5 pHash = g_Sandbox.pHashHead;
8697	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8698	while (pHash && (KUPTR)pHash != hHash)
8699	pHash = pHash->pNext;
8700	if (pHash)
8701	{
8702	if (pHash->uMagic == KWHASHMD5_MAGIC)
8703	{
8704	if (dwFlags == 0)
8705	{
8706	DWORD cbRet;
8707	void *pvRet;
8708	union
8709	{
8710	DWORD dw;
8711	} uBuf;
8712
8713	switch (dwParam)
8714	{
8715	case HP_HASHVAL:
8716	{
8717	/* Check the hash progress. */
8718	PKFSWCACHEDFILE pCachedFile = pHash->pCachedFile;
8719	if (pCachedFile)
8720	{
8721	if ( pCachedFile->cbCached == pHash->cbHashed
8722	&& !pHash->fGoneBad)
8723	{
8724	if (pCachedFile->fValidMd5)
8725	KWCRYPT_LOG(("Already calculated hash for %p/%s! [hit]\n", pCachedFile, pCachedFile->szPath));
8726	else
8727	{
8728	MD5Init(&pHash->Md5Ctx);
8729	MD5Update(&pHash->Md5Ctx, pCachedFile->pbCached, pCachedFile->cbCached);
8730	MD5Final(pCachedFile->abMd5Digest, &pHash->Md5Ctx);
8731	pCachedFile->fValidMd5 = K_TRUE;
8732	KWCRYPT_LOG(("Calculated hash for %p/%s.\n", pCachedFile, pCachedFile->szPath));
8733	}
8734	pvRet = pCachedFile->abMd5Digest;
8735	}
8736	else
8737	{
8738	/* This actually happens (iprt/string.h + common/alloc/alloc.cpp), at least
8739	from what I can tell, so just deal with it. */
8740	KWCRYPT_LOG(("CryptGetHashParam/HP_HASHVAL: Not at end of cached file! cbCached=%#x cbHashed=%#x fGoneBad=%d (%p/%p/%s)\n",
8741	pHash->pCachedFile->cbCached, pHash->cbHashed, pHash->fGoneBad,
8742	pHash, pCachedFile, pCachedFile->szPath));
8743	pHash->fFallbackMode = K_TRUE;
8744	pHash->pCachedFile = NULL;
8745	MD5Init(&pHash->Md5Ctx);
8746	MD5Update(&pHash->Md5Ctx, pCachedFile->pbCached, pHash->cbHashed);
8747	MD5Final(pHash->abDigest, &pHash->Md5Ctx);
8748	pvRet = pHash->abDigest;
8749	}
8750	pHash->fFinal = K_TRUE;
8751	cbRet = 16;
8752	break;
8753	}
8754	else if (pHash->fFallbackMode)
8755	{
8756	if (!pHash->fFinal)
8757	{
8758	pHash->fFinal = K_TRUE;
8759	MD5Final(pHash->abDigest, &pHash->Md5Ctx);
8760	}
8761	pvRet = pHash->abDigest;
8762	cbRet = 16;
8763	break;
8764	}
8765	else
8766	{
8767	kwErrPrintf("CryptGetHashParam/HP_HASHVAL: pCachedFile is NULL!!\n");
8768	SetLastError(ERROR_INVALID_SERVER_STATE);
8769	}
8770	return FALSE;
8771	}
8772
8773	case HP_HASHSIZE:
8774	uBuf.dw = 16;
8775	pvRet = &uBuf;
8776	cbRet = sizeof(DWORD);
8777	break;
8778
8779	case HP_ALGID:
8780	uBuf.dw = CALG_MD5;
8781	pvRet = &uBuf;
8782	cbRet = sizeof(DWORD);
8783	break;
8784
8785	default:
8786	kwErrPrintf("CryptGetHashParam: Unknown dwParam=%#x\n", dwParam);
8787	SetLastError(NTE_BAD_TYPE);
8788	return FALSE;
8789	}
8790
8791	/*
8792	* Copy out cbRet from pvRet.
8793	*/
8794	if (pbData)
8795	{
8796	if (*pcbData >= cbRet)
8797	{
8798	*pcbData = cbRet;
8799	kHlpMemCopy(pbData, pvRet, cbRet);
8800	if (cbRet == 4)
8801	KWCRYPT_LOG(("CryptGetHashParam/%#x/%p/%p: TRUE, cbRet=%#x data=%#x [cached]\n",
8802	dwParam, pHash, pHash->pCachedFile, cbRet, (DWORD *)pbData));
8803	else if (cbRet == 16)
8804	KWCRYPT_LOG(("CryptGetHashParam/%#x/%p/%p: TRUE, cbRet=%#x data=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x [cached]\n",
8805	dwParam, pHash, pHash->pCachedFile, cbRet,
8806	pbData[0], pbData[1], pbData[2], pbData[3],
8807	pbData[4], pbData[5], pbData[6], pbData[7],
8808	pbData[8], pbData[9], pbData[10], pbData[11],
8809	pbData[12], pbData[13], pbData[14], pbData[15]));
8810	else
8811	KWCRYPT_LOG(("CryptGetHashParam/%#x%/p%/%p: TRUE, cbRet=%#x [cached]\n",
8812	dwParam, pHash, pHash->pCachedFile, cbRet));
8813	return TRUE;
8814	}
8815
8816	kHlpMemCopy(pbData, pvRet, *pcbData);
8817	}
8818	SetLastError(ERROR_MORE_DATA);
8819	*pcbData = cbRet;
8820	KWCRYPT_LOG(("CryptGetHashParam/%#x: ERROR_MORE_DATA\n"));
8821	}
8822	else
8823	{
8824	kwErrPrintf("CryptGetHashParam: dwFlags is not zero: %#x!\n", dwFlags);
8825	SetLastError(NTE_BAD_FLAGS);
8826	}
8827	}
8828	else
8829	{
8830	kwErrPrintf("CryptGetHashParam: Invalid cached hash handle!!\n");
8831	SetLastError(NTE_BAD_HASH);
8832	}
8833	fRc = FALSE;
8834	}
8835	/*
8836	* Regular handle.
8837	*/
8838	else
8839	{
8840	fRc = CryptGetHashParam(hHash, dwParam, pbData, pcbData, dwFlags);
8841	KWCRYPT_LOG(("CryptGetHashParam(hHash=%p, dwParam=%#x (%d), pbData=%p, *pcbData=%#x, dwFlags=%#x) -> %d\n",
8842	hHash, dwParam, pbData, *pcbData, dwFlags, fRc));
8843	}
8844
8845	return fRc;
8846	}
8847
8848
8849	/** AdvApi32 - CryptDestroyHash */
8850	static BOOL WINAPI kwSandbox_Advapi32_CryptDestroyHash(HCRYPTHASH hHash)
8851	{
8852	BOOL fRc;
8853	PKWHASHMD5 pPrev = NULL;
8854	PKWHASHMD5 pHash = g_Sandbox.pHashHead;
8855	kHlpAssert(GetCurrentThreadId() == g_Sandbox.idMainThread);
8856	while (pHash && (KUPTR)pHash != hHash)
8857	{
8858	pPrev = pHash;
8859	pHash = pHash->pNext;
8860	}
8861	if (pHash)
8862	{
8863	if (pHash->uMagic == KWHASHMD5_MAGIC)
8864	{
8865	pHash->uMagic = 0;
8866	if (!pPrev)
8867	g_Sandbox.pHashHead = pHash->pNext;
8868	else
8869	pPrev->pNext = pHash->pNext;
8870	kHlpFree(pHash);
8871	KWCRYPT_LOG(("CryptDestroyHash(hHash=%p) -> 1 [cached]\n", hHash));
8872	fRc = TRUE;
8873	}
8874	else
8875	{
8876	kwErrPrintf("CryptDestroyHash: Invalid cached hash handle!!\n");
8877	KWCRYPT_LOG(("CryptDestroyHash(hHash=%p) -> FALSE! [cached]\n", hHash));
8878	SetLastError(ERROR_INVALID_HANDLE);
8879	fRc = FALSE;
8880	}
8881	}
8882	/*
8883	* Regular handle.
8884	*/
8885	else
8886	{
8887	fRc = CryptDestroyHash(hHash);
8888	KWCRYPT_LOG(("CryptDestroyHash(hHash=%p) -> %d\n", hHash, fRc));
8889	}
8890	return fRc;
8891	}
8892
8893	#endif /* WITH_HASH_MD5_CACHE */
8894
8895
8896	/*
8897	*
8898	* Reuse crypt context.
8899	* Reuse crypt context.
8900	* Reuse crypt context.
8901	*
8902	*
8903	* This saves a little bit of time and registry accesses each time CL, C1 or C1XX runs.
8904	*
8905	*/
8906
8907	#ifdef WITH_CRYPT_CTX_REUSE
8908
8909	/** AdvApi32 - CryptAcquireContextW. */
8910	static BOOL WINAPI kwSandbox_Advapi32_CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pwszContainer, LPCWSTR pwszProvider,
8911	DWORD dwProvType, DWORD dwFlags)
8912	{
8913	BOOL fRet;
8914
8915	/*
8916	* Lookup reusable context based on the input.
8917	*/
8918	KSIZE const cwcContainer = pwszContainer ? kwUtf16Len(pwszContainer) : 0;
8919	KSIZE const cwcProvider = pwszProvider ? kwUtf16Len(pwszProvider) : 0;
8920	KU32 iCtx = g_Sandbox.cCryptCtxs;
8921	while (iCtx-- > 0)
8922	{
8923	if ( g_Sandbox.aCryptCtxs[iCtx].cwcContainer == cwcContainer
8924	&& g_Sandbox.aCryptCtxs[iCtx].cwcProvider == cwcProvider
8925	&& g_Sandbox.aCryptCtxs[iCtx].dwProvType == dwProvType
8926	&& g_Sandbox.aCryptCtxs[iCtx].dwFlags == dwFlags
8927	&& kHlpMemComp(g_Sandbox.aCryptCtxs[iCtx].pwszContainer, pwszContainer, cwcContainer * sizeof(wchar_t)) == 0
8928	&& kHlpMemComp(g_Sandbox.aCryptCtxs[iCtx].pwszProvider, pwszProvider, cwcProvider * sizeof(wchar_t)) == 0)
8929	{
8930	if (CryptContextAddRef(g_Sandbox.aCryptCtxs[iCtx].hProv, NULL, 0))
8931	{
8932	*phProv = g_Sandbox.aCryptCtxs[iCtx].hProv;
8933	KWCRYPT_LOG(("CryptAcquireContextW(,%ls, %ls, %#x, %#x) -> TRUE, %p [reused]\n",
8934	pwszContainer, pwszProvider, dwProvType, dwFlags, *phProv));
8935	return TRUE;
8936	}
8937	}
8938	}
8939
8940	/*
8941	* Create it and enter it into the reused array if possible.
8942	*/
8943	fRet = CryptAcquireContextW(phProv, pwszContainer, pwszProvider, dwProvType, dwFlags);
8944	if (fRet)
8945	{
8946	iCtx = g_Sandbox.cCryptCtxs;
8947	if (iCtx < K_ELEMENTS(g_Sandbox.aCryptCtxs))
8948	{
8949	/* Try duplicate the input strings. */
8950	g_Sandbox.aCryptCtxs[iCtx].pwszContainer = kHlpDup(pwszContainer ? pwszContainer : L"",
8951	(cwcContainer + 1) * sizeof(wchar_t));
8952	if (g_Sandbox.aCryptCtxs[iCtx].pwszContainer)
8953	{
8954	g_Sandbox.aCryptCtxs[iCtx].pwszProvider = kHlpDup(pwszProvider ? pwszProvider : L"",
8955	(cwcProvider + 1) * sizeof(wchar_t));
8956	if (g_Sandbox.aCryptCtxs[iCtx].pwszProvider)
8957	{
8958	/* Add a couple of references just to be on the safe side and all that. */
8959	HCRYPTPROV hProv = *phProv;
8960	if (CryptContextAddRef(hProv, NULL, 0))
8961	{
8962	if (CryptContextAddRef(hProv, NULL, 0))
8963	{
8964	/* Okay, finish the entry and return success */
8965	g_Sandbox.aCryptCtxs[iCtx].hProv = hProv;
8966	g_Sandbox.aCryptCtxs[iCtx].dwProvType = dwProvType;
8967	g_Sandbox.aCryptCtxs[iCtx].dwFlags = dwFlags;
8968	g_Sandbox.cCryptCtxs = iCtx + 1;
8969
8970	KWCRYPT_LOG(("CryptAcquireContextW(,%ls, %ls, %#x, %#x) -> TRUE, %p [new]\n",
8971	pwszContainer, pwszProvider, dwProvType, dwFlags, *phProv));
8972	return TRUE;
8973	}
8974	CryptReleaseContext(hProv, 0);
8975	}
8976	KWCRYPT_LOG(("CryptAcquireContextW: CryptContextAddRef failed!\n"));
8977
8978	kHlpFree(g_Sandbox.aCryptCtxs[iCtx].pwszProvider);
8979	g_Sandbox.aCryptCtxs[iCtx].pwszProvider = NULL;
8980	}
8981	kHlpFree(g_Sandbox.aCryptCtxs[iCtx].pwszContainer);
8982	g_Sandbox.aCryptCtxs[iCtx].pwszContainer = NULL;
8983	}
8984	}
8985	else
8986	KWCRYPT_LOG(("CryptAcquireContextW: Too many crypt contexts to keep and reuse!\n"));
8987	}
8988
8989	KWCRYPT_LOG(("CryptAcquireContextW(,%ls, %ls, %#x, %#x) -> %d, %p\n",
8990	pwszContainer, pwszProvider, dwProvType, dwFlags, *phProv));
8991	return fRet;
8992	}
8993
8994
8995	/** AdvApi32 - CryptReleaseContext */
8996	static BOOL WINAPI kwSandbox_Advapi32_CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
8997	{
8998	BOOL fRet = CryptReleaseContext(hProv, dwFlags);
8999	KWCRYPT_LOG(("CryptReleaseContext(%p,%#x) -> %d\n", hProv, dwFlags, fRet));
9000	return fRet;
9001	}
9002
9003
9004	/** AdvApi32 - CryptContextAddRef */
9005	static BOOL WINAPI kwSandbox_Advapi32_CryptContextAddRef(HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags)
9006	{
9007	BOOL fRet = CryptContextAddRef(hProv, pdwReserved, dwFlags);
9008	KWCRYPT_LOG(("CryptContextAddRef(%p,%p,%#x) -> %d\n", hProv, pdwReserved, dwFlags, fRet));
9009	return fRet;
9010	}
9011
9012	#endif /* WITH_CRYPT_CTX_REUSE */
9013
9014	/*
9015	*
9016	* Structured exception handling.
9017	* Structured exception handling.
9018	* Structured exception handling.
9019	*
9020	*/
9021	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_X86)
9022
9023	# define EH_NONCONTINUABLE KU32_C(0x00000001)
9024	# define EH_UNWINDING KU32_C(0x00000002)
9025	# define EH_EXIT_UNWIND KU32_C(0x00000004)
9026	# define EH_STACK_INVALID KU32_C(0x00000008)
9027	# define EH_NESTED_CALL KU32_C(0x00000010)
9028
9029	typedef KU32 (__cdecl * volatile PFNXCPTHANDLER)(PEXCEPTION_RECORD, struct _EXCEPTION_REGISTRATION_RECORD*, PCONTEXT,
9030	struct _EXCEPTION_REGISTRATION_RECORD * volatile *);
9031	typedef struct _EXCEPTION_REGISTRATION_RECORD
9032	{
9033	struct _EXCEPTION_REGISTRATION_RECORD * volatile pPrevRegRec;
9034	PFNXCPTHANDLER pfnXcptHandler;
9035	};
9036
9037
9038	/**
9039	* Calls @a pfnHandler.
9040	*/
9041	static KU32 kwSandboxXcptCallHandler(PEXCEPTION_RECORD pXcptRec, struct _EXCEPTION_REGISTRATION_RECORD *pRegRec,
9042	PCONTEXT pXcptCtx, struct _EXCEPTION_REGISTRATION_RECORD * volatile * ppRegRec,
9043	PFNXCPTHANDLER pfnHandler)
9044	{
9045	# if 1
9046	/* This is a more robust version that isn't subject to calling
9047	convension cleanup disputes and such. */
9048	KU32 uSavedEdi;
9049	KU32 uSavedEsi;
9050	KU32 uSavedEbx;
9051	KU32 rcHandler;
9052
9053	__asm
9054	{
9055	mov [uSavedEdi], edi
9056	mov [uSavedEsi], esi
9057	mov [uSavedEbx], ebx
9058	mov esi, esp
9059	mov edi, esp
9060	mov edi, [pXcptRec]
9061	mov edx, [pRegRec]
9062	mov eax, [pXcptCtx]
9063	mov ebx, [ppRegRec]
9064	mov ecx, [pfnHandler]
9065	sub esp, 16
9066	and esp, 0fffffff0h
9067	mov [esp ], edi
9068	mov [esp + 4], edx
9069	mov [esp + 8], eax
9070	mov [esp + 12], ebx
9071	mov edi, esi
9072	call ecx
9073	mov esp, esi
9074	cmp esp, edi
9075	je stack_ok
9076	int 3
9077	stack_ok:
9078	mov edi, [uSavedEdi]
9079	mov esi, [uSavedEsi]
9080	mov ebx, [uSavedEbx]
9081	mov [rcHandler], eax
9082	}
9083	return rcHandler;
9084	# else
9085	return pfnHandler(pXcptRec, pRegRec, pXctpCtx, ppRegRec);
9086	# endif
9087	}
9088
9089
9090	/**
9091	* Vectored exception handler that emulates x86 chained exception handler.
9092	*
9093	* This is necessary because the RtlIsValidHandler check fails for self loaded
9094	* code and prevents cl.exe from working. (On AMD64 we can register function
9095	* tables, but on X86 cooking your own handling seems to be the only viabke
9096	* alternative.)
9097	*
9098	* @returns EXCEPTION_CONTINUE_SEARCH or EXCEPTION_CONTINUE_EXECUTION.
9099	* @param pXcptPtrs The exception details.
9100	*/
9101	static LONG CALLBACK kwSandboxVecXcptEmulateChained(PEXCEPTION_POINTERS pXcptPtrs)
9102	{
9103	PNT_TIB pTib = (PNT_TIB)NtCurrentTeb();
9104	KW_LOG(("kwSandboxVecXcptEmulateChained: %#x\n", pXcptPtrs->ExceptionRecord->ExceptionCode));
9105	if (g_Sandbox.fRunning)
9106	{
9107	HANDLE const hCurProc = GetCurrentProcess();
9108	PEXCEPTION_RECORD pXcptRec = pXcptPtrs->ExceptionRecord;
9109	PCONTEXT pXcptCtx = pXcptPtrs->ContextRecord;
9110	struct _EXCEPTION_REGISTRATION_RECORD * pRegRec = pTib->ExceptionList;
9111	while (((KUPTR)pRegRec & (sizeof(void *) - 3)) == 0 && pRegRec != NULL)
9112	{
9113	/* Read the exception record in a safe manner. */
9114	struct _EXCEPTION_REGISTRATION_RECORD RegRec;
9115	DWORD cbActuallyRead = 0;
9116	if ( ReadProcessMemory(hCurProc, pRegRec, &RegRec, sizeof(RegRec), &cbActuallyRead)
9117	&& cbActuallyRead == sizeof(RegRec))
9118	{
9119	struct _EXCEPTION_REGISTRATION_RECORD * volatile pDispRegRec = NULL;
9120	KU32 rcHandler;
9121	KW_LOG(("kwSandboxVecXcptEmulateChained: calling %p, pRegRec=%p, pPrevRegRec=%p\n",
9122	RegRec.pfnXcptHandler, pRegRec, RegRec.pPrevRegRec));
9123	rcHandler = kwSandboxXcptCallHandler(pXcptRec, pRegRec, pXcptCtx, &pDispRegRec, RegRec.pfnXcptHandler);
9124	KW_LOG(("kwSandboxVecXcptEmulateChained: rcHandler=%#x pDispRegRec=%p\n", rcHandler, pDispRegRec));
9125	if (rcHandler == ExceptionContinueExecution)
9126	{
9127	kHlpAssert(!(pXcptPtrs->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE));
9128	KW_LOG(("kwSandboxVecXcptEmulateChained: returning EXCEPTION_CONTINUE_EXECUTION!\n"));
9129	return EXCEPTION_CONTINUE_EXECUTION;
9130	}
9131
9132	if (rcHandler == ExceptionContinueSearch)
9133	kHlpAssert(!(pXcptPtrs->ExceptionRecord->ExceptionFlags & 8 /EXCEPTION_STACK_INVALID/));
9134	else if (rcHandler == ExceptionNestedException)
9135	kHlpAssertMsgFailed(("Nested exceptions.\n"));
9136	else
9137	kHlpAssertMsgFailed(("Invalid return %#x (%d).\n", rcHandler, rcHandler));
9138	}
9139	else
9140	{
9141	KW_LOG(("kwSandboxVecXcptEmulateChained: Bad xcpt chain entry at %p! Stopping search.\n", pRegRec));
9142	break;
9143	}
9144
9145	/*
9146	* Next.
9147	*/
9148	pRegRec = RegRec.pPrevRegRec;
9149	}
9150	}
9151	return EXCEPTION_CONTINUE_SEARCH;
9152	}
9153
9154
9155	/** NtDll,Kernel32 - RtlUnwind */
9156	static VOID WINAPI kwSandbox_ntdll_RtlUnwind(struct _EXCEPTION_REGISTRATION_RECORD *pStopXcptRec, PVOID pvTargetIp,
9157	PEXCEPTION_RECORD pXcptRec, PVOID pvReturnValue)
9158	{
9159	PNT_TIB pTib = (PNT_TIB)NtCurrentTeb();
9160	KW_LOG(("kwSandbox_ntdll_RtlUnwind: pStopXcptRec=%p pvTargetIp=%p pXctpRec=%p pvReturnValue=%p%s\n",
9161	pStopXcptRec, pvTargetIp, pXcptRec, pvReturnValue, g_Sandbox.fRunning ? "" : " [sandbox not running]"));
9162	if (g_Sandbox.fRunning)
9163	{
9164	HANDLE const hCurProc = GetCurrentProcess();
9165	PCONTEXT pXcptCtx = NULL;
9166	struct _EXCEPTION_REGISTRATION_RECORD * pRegRec = pTib->ExceptionList;
9167
9168	/*
9169	* Update / create an exception record.
9170	*/
9171	if (pXcptRec)
9172	pXcptRec->ExceptionFlags \|= EH_UNWINDING;
9173	else
9174	{
9175	pXcptRec = (PEXCEPTION_RECORD)alloca(sizeof(*pXcptRec));
9176	kHlpMemSet(pXcptRec, 0, sizeof(*pXcptRec));
9177	pXcptRec->ExceptionCode = STATUS_UNWIND;
9178	pXcptRec->ExceptionFlags = EH_UNWINDING;
9179	}
9180	if (!pStopXcptRec)
9181	pXcptRec->ExceptionFlags \|= EH_EXIT_UNWIND;
9182
9183	/*
9184	* Walk the chain till we find pStopXctpRec.
9185	*/
9186	while ( ((KUPTR)pRegRec & (sizeof(void *) - 3)) == 0
9187	&& pRegRec != NULL
9188	&& pRegRec != pStopXcptRec)
9189	{
9190	/* Read the exception record in a safe manner. */
9191	struct _EXCEPTION_REGISTRATION_RECORD RegRec;
9192	DWORD cbActuallyRead = 0;
9193	if ( ReadProcessMemory(hCurProc, pRegRec, &RegRec, sizeof(RegRec), &cbActuallyRead)
9194	&& cbActuallyRead == sizeof(RegRec))
9195	{
9196	struct _EXCEPTION_REGISTRATION_RECORD * volatile pDispRegRec = NULL;
9197	KU32 rcHandler;
9198	KW_LOG(("kwSandbox_ntdll_RtlUnwind: calling %p, pRegRec=%p, pPrevRegRec=%p\n",
9199	RegRec.pfnXcptHandler, pRegRec, RegRec.pPrevRegRec));
9200	rcHandler = kwSandboxXcptCallHandler(pXcptRec, pRegRec, pXcptCtx, &pDispRegRec, RegRec.pfnXcptHandler);
9201	KW_LOG(("kwSandbox_ntdll_RtlUnwind: rcHandler=%#x pDispRegRec=%p\n", rcHandler, pDispRegRec));
9202
9203	if (rcHandler == ExceptionContinueSearch)
9204	kHlpAssert(!(pXcptRec->ExceptionFlags & 8 /EXCEPTION_STACK_INVALID/));
9205	else if (rcHandler == ExceptionCollidedUnwind)
9206	kHlpAssertMsgFailed(("Implement collided unwind!\n"));
9207	else
9208	kHlpAssertMsgFailed(("Invalid return %#x (%d).\n", rcHandler, rcHandler));
9209	}
9210	else
9211	{
9212	KW_LOG(("kwSandbox_ntdll_RtlUnwind: Bad xcpt chain entry at %p! Stopping search.\n", pRegRec));
9213	break;
9214	}
9215
9216	/*
9217	* Pop next.
9218	*/
9219	pTib->ExceptionList = RegRec.pPrevRegRec;
9220	pRegRec = RegRec.pPrevRegRec;
9221	}
9222	return;
9223	}
9224
9225	RtlUnwind(pStopXcptRec, pvTargetIp, pXcptRec, pvReturnValue);
9226	}
9227
9228	#endif /* WINDOWS + X86 */
9229
9230
9231	/*
9232	*
9233	* Misc function only intercepted while debugging.
9234	* Misc function only intercepted while debugging.
9235	* Misc function only intercepted while debugging.
9236	*
9237	*/
9238
9239	#ifndef NDEBUG
9240
9241	/** CRT - memcpy */
9242	static void * __cdecl kwSandbox_msvcrt_memcpy(void pvDst, void const pvSrc, size_t cb)
9243	{
9244	KU8 const pbSrc = (KU8 const )pvSrc;
9245	KU8 pbDst = (KU8 )pvDst;
9246	KSIZE cbLeft = cb;
9247	while (cbLeft-- > 0)
9248	pbDst++ = pbSrc++;
9249	return pvDst;
9250	}
9251
9252
9253	/** CRT - memset */
9254	static void * __cdecl kwSandbox_msvcrt_memset(void *pvDst, int bFiller, size_t cb)
9255	{
9256	KU8 pbDst = (KU8 )pvDst;
9257	KSIZE cbLeft = cb;
9258	while (cbLeft-- > 0)
9259	*pbDst++ = bFiller;
9260	return pvDst;
9261	}
9262
9263	#endif /* NDEBUG */
9264
9265
9266
9267	/**
9268	* Functions that needs replacing for sandboxed execution.
9269	*/
9270	KWREPLACEMENTFUNCTION const g_aSandboxReplacements[] =
9271	{
9272	/*
9273	* Kernel32.dll and friends.
9274	*/
9275	{ TUPLE("ExitProcess"), NULL, (KUPTR)kwSandbox_Kernel32_ExitProcess },
9276	{ TUPLE("TerminateProcess"), NULL, (KUPTR)kwSandbox_Kernel32_TerminateProcess },
9277
9278	{ TUPLE("LoadLibraryA"), NULL, (KUPTR)kwSandbox_Kernel32_LoadLibraryA },
9279	{ TUPLE("LoadLibraryW"), NULL, (KUPTR)kwSandbox_Kernel32_LoadLibraryW },
9280	{ TUPLE("LoadLibraryExA"), NULL, (KUPTR)kwSandbox_Kernel32_LoadLibraryExA },
9281	{ TUPLE("LoadLibraryExW"), NULL, (KUPTR)kwSandbox_Kernel32_LoadLibraryExW },
9282	{ TUPLE("FreeLibrary"), NULL, (KUPTR)kwSandbox_Kernel32_FreeLibrary },
9283	{ TUPLE("GetModuleHandleA"), NULL, (KUPTR)kwSandbox_Kernel32_GetModuleHandleA },
9284	{ TUPLE("GetModuleHandleW"), NULL, (KUPTR)kwSandbox_Kernel32_GetModuleHandleW },
9285	{ TUPLE("GetProcAddress"), NULL, (KUPTR)kwSandbox_Kernel32_GetProcAddress },
9286	{ TUPLE("GetModuleFileNameA"), NULL, (KUPTR)kwSandbox_Kernel32_GetModuleFileNameA },
9287	{ TUPLE("GetModuleFileNameW"), NULL, (KUPTR)kwSandbox_Kernel32_GetModuleFileNameW },
9288	{ TUPLE("RtlPcToFileHeader"), NULL, (KUPTR)kwSandbox_ntdll_RtlPcToFileHeader },
9289
9290	{ TUPLE("GetCommandLineA"), NULL, (KUPTR)kwSandbox_Kernel32_GetCommandLineA },
9291	{ TUPLE("GetCommandLineW"), NULL, (KUPTR)kwSandbox_Kernel32_GetCommandLineW },
9292	{ TUPLE("GetStartupInfoA"), NULL, (KUPTR)kwSandbox_Kernel32_GetStartupInfoA },
9293	{ TUPLE("GetStartupInfoW"), NULL, (KUPTR)kwSandbox_Kernel32_GetStartupInfoW },
9294
9295	{ TUPLE("CreateThread"), NULL, (KUPTR)kwSandbox_Kernel32_CreateThread },
9296
9297	{ TUPLE("GetEnvironmentStrings"), NULL, (KUPTR)kwSandbox_Kernel32_GetEnvironmentStrings },
9298	{ TUPLE("GetEnvironmentStringsA"), NULL, (KUPTR)kwSandbox_Kernel32_GetEnvironmentStringsA },
9299	{ TUPLE("GetEnvironmentStringsW"), NULL, (KUPTR)kwSandbox_Kernel32_GetEnvironmentStringsW },
9300	{ TUPLE("FreeEnvironmentStringsA"), NULL, (KUPTR)kwSandbox_Kernel32_FreeEnvironmentStringsA },
9301	{ TUPLE("FreeEnvironmentStringsW"), NULL, (KUPTR)kwSandbox_Kernel32_FreeEnvironmentStringsW },
9302	{ TUPLE("GetEnvironmentVariableA"), NULL, (KUPTR)kwSandbox_Kernel32_GetEnvironmentVariableA },
9303	{ TUPLE("GetEnvironmentVariableW"), NULL, (KUPTR)kwSandbox_Kernel32_GetEnvironmentVariableW },
9304	{ TUPLE("SetEnvironmentVariableA"), NULL, (KUPTR)kwSandbox_Kernel32_SetEnvironmentVariableA },
9305	{ TUPLE("SetEnvironmentVariableW"), NULL, (KUPTR)kwSandbox_Kernel32_SetEnvironmentVariableW },
9306	{ TUPLE("ExpandEnvironmentStringsA"), NULL, (KUPTR)kwSandbox_Kernel32_ExpandEnvironmentStringsA },
9307	{ TUPLE("ExpandEnvironmentStringsW"), NULL, (KUPTR)kwSandbox_Kernel32_ExpandEnvironmentStringsW },
9308
9309	{ TUPLE("CreateFileA"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileA },
9310	{ TUPLE("CreateFileW"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileW },
9311	{ TUPLE("ReadFile"), NULL, (KUPTR)kwSandbox_Kernel32_ReadFile },
9312	{ TUPLE("ReadFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_ReadFileEx },
9313	#ifdef WITH_TEMP_MEMORY_FILES
9314	{ TUPLE("WriteFile"), NULL, (KUPTR)kwSandbox_Kernel32_WriteFile },
9315	{ TUPLE("WriteFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_WriteFileEx },
9316	{ TUPLE("SetEndOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_SetEndOfFile },
9317	{ TUPLE("GetFileType"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileType },
9318	{ TUPLE("GetFileSize"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileSize },
9319	{ TUPLE("GetFileSizeEx"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileSizeEx },
9320	{ TUPLE("CreateFileMappingW"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileMappingW },
9321	{ TUPLE("MapViewOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_MapViewOfFile },
9322	{ TUPLE("MapViewOfFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_MapViewOfFileEx },
9323	{ TUPLE("UnmapViewOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_UnmapViewOfFile },
9324	#endif
9325	{ TUPLE("SetFilePointer"), NULL, (KUPTR)kwSandbox_Kernel32_SetFilePointer },
9326	{ TUPLE("SetFilePointerEx"), NULL, (KUPTR)kwSandbox_Kernel32_SetFilePointerEx },
9327	{ TUPLE("DuplicateHandle"), NULL, (KUPTR)kwSandbox_Kernel32_DuplicateHandle },
9328	{ TUPLE("CloseHandle"), NULL, (KUPTR)kwSandbox_Kernel32_CloseHandle },
9329	{ TUPLE("GetFileAttributesA"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileAttributesA },
9330	{ TUPLE("GetFileAttributesW"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileAttributesW },
9331	{ TUPLE("GetShortPathNameW"), NULL, (KUPTR)kwSandbox_Kernel32_GetShortPathNameW },
9332	#ifdef WITH_TEMP_MEMORY_FILES
9333	{ TUPLE("DeleteFileW"), NULL, (KUPTR)kwSandbox_Kernel32_DeleteFileW },
9334	#endif
9335
9336	{ TUPLE("WriteConsoleA"), NULL, (KUPTR)kwSandbox_Kernel32_WriteConsoleA },
9337	{ TUPLE("WriteConsoleW"), NULL, (KUPTR)kwSandbox_Kernel32_WriteConsoleW },
9338
9339	{ TUPLE("VirtualAlloc"), NULL, (KUPTR)kwSandbox_Kernel32_VirtualAlloc },
9340	{ TUPLE("VirtualFree"), NULL, (KUPTR)kwSandbox_Kernel32_VirtualFree },
9341
9342	{ TUPLE("HeapCreate"), NULL, (KUPTR)kwSandbox_Kernel32_HeapCreate, K_TRUE /fOnlyExe/ },
9343	{ TUPLE("HeapDestroy"), NULL, (KUPTR)kwSandbox_Kernel32_HeapDestroy, K_TRUE /fOnlyExe/ },
9344
9345	{ TUPLE("FlsAlloc"), NULL, (KUPTR)kwSandbox_Kernel32_FlsAlloc, K_TRUE /fOnlyExe/ },
9346	{ TUPLE("FlsFree"), NULL, (KUPTR)kwSandbox_Kernel32_FlsFree, K_TRUE /fOnlyExe/ },
9347	{ TUPLE("TlsAlloc"), NULL, (KUPTR)kwSandbox_Kernel32_TlsAlloc, K_TRUE /fOnlyExe/ },
9348	{ TUPLE("TlsFree"), NULL, (KUPTR)kwSandbox_Kernel32_TlsFree, K_TRUE /fOnlyExe/ },
9349
9350	{ TUPLE("SetConsoleCtrlHandler"), NULL, (KUPTR)kwSandbox_Kernel32_SetConsoleCtrlHandler },
9351
9352	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_X86)
9353	{ TUPLE("RtlUnwind"), NULL, (KUPTR)kwSandbox_ntdll_RtlUnwind },
9354	#endif
9355
9356	#ifdef WITH_HASH_MD5_CACHE
9357	{ TUPLE("CryptCreateHash"), NULL, (KUPTR)kwSandbox_Advapi32_CryptCreateHash },
9358	{ TUPLE("CryptHashData"), NULL, (KUPTR)kwSandbox_Advapi32_CryptHashData },
9359	{ TUPLE("CryptGetHashParam"), NULL, (KUPTR)kwSandbox_Advapi32_CryptGetHashParam },
9360	{ TUPLE("CryptDestroyHash"), NULL, (KUPTR)kwSandbox_Advapi32_CryptDestroyHash },
9361	#endif
9362
9363	#ifdef WITH_CRYPT_CTX_REUSE
9364	{ TUPLE("CryptAcquireContextW"), NULL, (KUPTR)kwSandbox_Advapi32_CryptAcquireContextW },
9365	{ TUPLE("CryptReleaseContext"), NULL, (KUPTR)kwSandbox_Advapi32_CryptReleaseContext },
9366	{ TUPLE("CryptContextAddRef"), NULL, (KUPTR)kwSandbox_Advapi32_CryptContextAddRef },
9367	#endif
9368
9369	/*
9370	* MS Visual C++ CRTs.
9371	*/
9372	{ TUPLE("exit"), NULL, (KUPTR)kwSandbox_msvcrt_exit },
9373	{ TUPLE("_exit"), NULL, (KUPTR)kwSandbox_msvcrt__exit },
9374	{ TUPLE("_cexit"), NULL, (KUPTR)kwSandbox_msvcrt__cexit },
9375	{ TUPLE("_c_exit"), NULL, (KUPTR)kwSandbox_msvcrt__c_exit },
9376	{ TUPLE("_amsg_exit"), NULL, (KUPTR)kwSandbox_msvcrt__amsg_exit },
9377	{ TUPLE("terminate"), NULL, (KUPTR)kwSandbox_msvcrt_terminate },
9378
9379	{ TUPLE("onexit"), NULL, (KUPTR)kwSandbox_msvcrt__onexit, K_TRUE /fOnlyExe/ },
9380	{ TUPLE("_onexit"), NULL, (KUPTR)kwSandbox_msvcrt__onexit, K_TRUE /fOnlyExe/ },
9381	{ TUPLE("atexit"), NULL, (KUPTR)kwSandbox_msvcrt_atexit, K_TRUE /fOnlyExe/ },
9382
9383	{ TUPLE("_beginthread"), NULL, (KUPTR)kwSandbox_msvcrt__beginthread },
9384	{ TUPLE("_beginthreadex"), NULL, (KUPTR)kwSandbox_msvcrt__beginthreadex },
9385	{ TUPLE("_beginthreadex"), "msvcr120.dll", (KUPTR)kwSandbox_msvcr120__beginthreadex }, /* higher priority last */
9386
9387	{ TUPLE("__argc"), NULL, (KUPTR)&g_Sandbox.cArgs },
9388	{ TUPLE("__argv"), NULL, (KUPTR)&g_Sandbox.papszArgs },
9389	{ TUPLE("__wargv"), NULL, (KUPTR)&g_Sandbox.papwszArgs },
9390	{ TUPLE("__p___argc"), NULL, (KUPTR)kwSandbox_msvcrt___p___argc },
9391	{ TUPLE("__p___argv"), NULL, (KUPTR)kwSandbox_msvcrt___p___argv },
9392	{ TUPLE("__p___wargv"), NULL, (KUPTR)kwSandbox_msvcrt___p___wargv },
9393	{ TUPLE("_acmdln"), NULL, (KUPTR)&g_Sandbox.pszCmdLine },
9394	{ TUPLE("_wcmdln"), NULL, (KUPTR)&g_Sandbox.pwszCmdLine },
9395	{ TUPLE("__p__acmdln"), NULL, (KUPTR)kwSandbox_msvcrt___p__acmdln },
9396	{ TUPLE("__p__wcmdln"), NULL, (KUPTR)kwSandbox_msvcrt___p__wcmdln },
9397	{ TUPLE("_pgmptr"), NULL, (KUPTR)&g_Sandbox.pgmptr },
9398	{ TUPLE("_wpgmptr"), NULL, (KUPTR)&g_Sandbox.wpgmptr },
9399	{ TUPLE("_get_pgmptr"), NULL, (KUPTR)kwSandbox_msvcrt__get_pgmptr },
9400	{ TUPLE("_get_wpgmptr"), NULL, (KUPTR)kwSandbox_msvcrt__get_wpgmptr },
9401	{ TUPLE("__p__pgmptr"), NULL, (KUPTR)kwSandbox_msvcrt___p__pgmptr },
9402	{ TUPLE("__p__wpgmptr"), NULL, (KUPTR)kwSandbox_msvcrt___p__wpgmptr },
9403	{ TUPLE("_wincmdln"), NULL, (KUPTR)kwSandbox_msvcrt__wincmdln },
9404	{ TUPLE("_wwincmdln"), NULL, (KUPTR)kwSandbox_msvcrt__wwincmdln },
9405	{ TUPLE("__getmainargs"), NULL, (KUPTR)kwSandbox_msvcrt___getmainargs},
9406	{ TUPLE("__wgetmainargs"), NULL, (KUPTR)kwSandbox_msvcrt___wgetmainargs},
9407
9408	{ TUPLE("_putenv"), NULL, (KUPTR)kwSandbox_msvcrt__putenv},
9409	{ TUPLE("_wputenv"), NULL, (KUPTR)kwSandbox_msvcrt__wputenv},
9410	{ TUPLE("_putenv_s"), NULL, (KUPTR)kwSandbox_msvcrt__putenv_s},
9411	{ TUPLE("_wputenv_s"), NULL, (KUPTR)kwSandbox_msvcrt__wputenv_s},
9412	{ TUPLE("__initenv"), NULL, (KUPTR)&g_Sandbox.initenv },
9413	{ TUPLE("__winitenv"), NULL, (KUPTR)&g_Sandbox.winitenv },
9414	{ TUPLE("__p___initenv"), NULL, (KUPTR)kwSandbox_msvcrt___p___initenv},
9415	{ TUPLE("__p___winitenv"), NULL, (KUPTR)kwSandbox_msvcrt___p___winitenv},
9416	{ TUPLE("_environ"), NULL, (KUPTR)&g_Sandbox.environ },
9417	{ TUPLE("_wenviron"), NULL, (KUPTR)&g_Sandbox.wenviron },
9418	{ TUPLE("_get_environ"), NULL, (KUPTR)kwSandbox_msvcrt__get_environ },
9419	{ TUPLE("_get_wenviron"), NULL, (KUPTR)kwSandbox_msvcrt__get_wenviron },
9420	{ TUPLE("__p__environ"), NULL, (KUPTR)kwSandbox_msvcrt___p__environ },
9421	{ TUPLE("__p__wenviron"), NULL, (KUPTR)kwSandbox_msvcrt___p__wenviron },
9422
9423	#ifndef NDEBUG
9424	{ TUPLE("memcpy"), NULL, (KUPTR)kwSandbox_msvcrt_memcpy },
9425	{ TUPLE("memset"), NULL, (KUPTR)kwSandbox_msvcrt_memset },
9426	#endif
9427	};
9428	/** Number of entries in g_aReplacements. */
9429	KU32 const g_cSandboxReplacements = K_ELEMENTS(g_aSandboxReplacements);
9430
9431
9432	/**
9433	* Functions that needs replacing in natively loaded DLLs when doing sandboxed
9434	* execution.
9435	*/
9436	KWREPLACEMENTFUNCTION const g_aSandboxNativeReplacements[] =
9437	{
9438	/*
9439	* Kernel32.dll and friends.
9440	*/
9441	{ TUPLE("ExitProcess"), NULL, (KUPTR)kwSandbox_Kernel32_ExitProcess },
9442	{ TUPLE("TerminateProcess"), NULL, (KUPTR)kwSandbox_Kernel32_TerminateProcess },
9443
9444	#if 0
9445	{ TUPLE("CreateThread"), NULL, (KUPTR)kwSandbox_Kernel32_CreateThread },
9446	#endif
9447
9448	{ TUPLE("CreateFileA"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileA },
9449	{ TUPLE("CreateFileW"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileW },
9450	{ TUPLE("ReadFile"), NULL, (KUPTR)kwSandbox_Kernel32_ReadFile },
9451	{ TUPLE("ReadFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_ReadFileEx },
9452	#ifdef WITH_TEMP_MEMORY_FILES
9453	{ TUPLE("WriteFile"), NULL, (KUPTR)kwSandbox_Kernel32_WriteFile },
9454	{ TUPLE("WriteFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_WriteFileEx },
9455	{ TUPLE("SetEndOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_SetEndOfFile },
9456	{ TUPLE("GetFileType"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileType },
9457	{ TUPLE("GetFileSize"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileSize },
9458	{ TUPLE("GetFileSizeEx"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileSizeEx },
9459	{ TUPLE("CreateFileMappingW"), NULL, (KUPTR)kwSandbox_Kernel32_CreateFileMappingW },
9460	{ TUPLE("MapViewOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_MapViewOfFile },
9461	{ TUPLE("MapViewOfFileEx"), NULL, (KUPTR)kwSandbox_Kernel32_MapViewOfFileEx },
9462	{ TUPLE("UnmapViewOfFile"), NULL, (KUPTR)kwSandbox_Kernel32_UnmapViewOfFile },
9463	#endif
9464	{ TUPLE("SetFilePointer"), NULL, (KUPTR)kwSandbox_Kernel32_SetFilePointer },
9465	{ TUPLE("SetFilePointerEx"), NULL, (KUPTR)kwSandbox_Kernel32_SetFilePointerEx },
9466	{ TUPLE("DuplicateHandle"), NULL, (KUPTR)kwSandbox_Kernel32_DuplicateHandle },
9467	{ TUPLE("CloseHandle"), NULL, (KUPTR)kwSandbox_Kernel32_CloseHandle },
9468	{ TUPLE("GetFileAttributesA"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileAttributesA },
9469	{ TUPLE("GetFileAttributesW"), NULL, (KUPTR)kwSandbox_Kernel32_GetFileAttributesW },
9470	{ TUPLE("GetShortPathNameW"), NULL, (KUPTR)kwSandbox_Kernel32_GetShortPathNameW },
9471	#ifdef WITH_TEMP_MEMORY_FILES
9472	{ TUPLE("DeleteFileW"), NULL, (KUPTR)kwSandbox_Kernel32_DeleteFileW },
9473	#endif
9474	{ TUPLE("SetConsoleCtrlHandler"), NULL, (KUPTR)kwSandbox_Kernel32_SetConsoleCtrlHandler },
9475	{ TUPLE("LoadLibraryExA"), NULL, (KUPTR)kwSandbox_Kernel32_Native_LoadLibraryExA },
9476
9477	{ TUPLE("WriteConsoleA"), NULL, (KUPTR)kwSandbox_Kernel32_WriteConsoleA },
9478	{ TUPLE("WriteConsoleW"), NULL, (KUPTR)kwSandbox_Kernel32_WriteConsoleW },
9479
9480	#ifdef WITH_HASH_MD5_CACHE
9481	{ TUPLE("CryptCreateHash"), NULL, (KUPTR)kwSandbox_Advapi32_CryptCreateHash },
9482	{ TUPLE("CryptHashData"), NULL, (KUPTR)kwSandbox_Advapi32_CryptHashData },
9483	{ TUPLE("CryptGetHashParam"), NULL, (KUPTR)kwSandbox_Advapi32_CryptGetHashParam },
9484	{ TUPLE("CryptDestroyHash"), NULL, (KUPTR)kwSandbox_Advapi32_CryptDestroyHash },
9485	#endif
9486
9487	{ TUPLE("RtlPcToFileHeader"), NULL, (KUPTR)kwSandbox_ntdll_RtlPcToFileHeader },
9488
9489	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_X86)
9490	{ TUPLE("RtlUnwind"), NULL, (KUPTR)kwSandbox_ntdll_RtlUnwind },
9491	#endif
9492
9493	/*
9494	* MS Visual C++ CRTs.
9495	*/
9496	{ TUPLE("exit"), NULL, (KUPTR)kwSandbox_msvcrt_exit },
9497	{ TUPLE("_exit"), NULL, (KUPTR)kwSandbox_msvcrt__exit },
9498	{ TUPLE("_cexit"), NULL, (KUPTR)kwSandbox_msvcrt__cexit },
9499	{ TUPLE("_c_exit"), NULL, (KUPTR)kwSandbox_msvcrt__c_exit },
9500	{ TUPLE("_amsg_exit"), NULL, (KUPTR)kwSandbox_msvcrt__amsg_exit },
9501	{ TUPLE("terminate"), NULL, (KUPTR)kwSandbox_msvcrt_terminate },
9502
9503	#if 0 /* used by mspdbXXX.dll */
9504	{ TUPLE("_beginthread"), NULL, (KUPTR)kwSandbox_msvcrt__beginthread },
9505	{ TUPLE("_beginthreadex"), NULL, (KUPTR)kwSandbox_msvcrt__beginthreadex },
9506	#endif
9507	};
9508	/** Number of entries in g_aSandboxNativeReplacements. */
9509	KU32 const g_cSandboxNativeReplacements = K_ELEMENTS(g_aSandboxNativeReplacements);
9510
9511
9512	/**
9513	* Functions that needs replacing when queried by GetProcAddress.
9514	*/
9515	KWREPLACEMENTFUNCTION const g_aSandboxGetProcReplacements[] =
9516	{
9517	/*
9518	* Kernel32.dll and friends.
9519	*/
9520	{ TUPLE("FlsAlloc"), NULL, (KUPTR)kwSandbox_Kernel32_FlsAlloc, K_TRUE /fOnlyExe/ },
9521	{ TUPLE("FlsFree"), NULL, (KUPTR)kwSandbox_Kernel32_FlsFree, K_TRUE /fOnlyExe/ },
9522	{ TUPLE("TlsAlloc"), NULL, (KUPTR)kwSandbox_Kernel32_TlsAlloc, K_TRUE /fOnlyExe/ },
9523	{ TUPLE("TlsFree"), NULL, (KUPTR)kwSandbox_Kernel32_TlsFree, K_TRUE /fOnlyExe/ },
9524	};
9525	/** Number of entries in g_aSandboxGetProcReplacements. */
9526	KU32 const g_cSandboxGetProcReplacements = K_ELEMENTS(g_aSandboxGetProcReplacements);
9527
9528
9529	/**
9530	* Control handler.
9531	*
9532	* @returns TRUE if handled, FALSE if not.
9533	* @param dwCtrlType The signal.
9534	*/
9535	static BOOL WINAPI kwSandboxCtrlHandler(DWORD dwCtrlType)
9536	{
9537	switch (dwCtrlType)
9538	{
9539	case CTRL_C_EVENT:
9540	fprintf(stderr, "kWorker: Ctrl-C\n");
9541	g_fCtrlC = K_TRUE;
9542	exit(9);
9543	break;
9544
9545	case CTRL_BREAK_EVENT:
9546	fprintf(stderr, "kWorker: Ctrl-Break\n");
9547	g_fCtrlC = K_TRUE;
9548	exit(10);
9549	break;
9550
9551	case CTRL_CLOSE_EVENT:
9552	fprintf(stderr, "kWorker: console closed\n");
9553	g_fCtrlC = K_TRUE;
9554	exit(11);
9555	break;
9556
9557	case CTRL_LOGOFF_EVENT:
9558	fprintf(stderr, "kWorker: logoff event\n");
9559	g_fCtrlC = K_TRUE;
9560	exit(11);
9561	break;
9562
9563	case CTRL_SHUTDOWN_EVENT:
9564	fprintf(stderr, "kWorker: shutdown event\n");
9565	g_fCtrlC = K_TRUE;
9566	exit(11);
9567	break;
9568
9569	default:
9570	fprintf(stderr, "kwSandboxCtrlHandler: %#x\n", dwCtrlType);
9571	break;
9572	}
9573	return TRUE;
9574	}
9575
9576
9577	/**
9578	* Used by kwSandboxExec to reset the state of the module tree.
9579	*
9580	* This is done recursively.
9581	*
9582	* @param pMod The root of the tree to consider.
9583	*/
9584	static void kwSandboxResetModuleState(PKWMODULE pMod)
9585	{
9586	if ( !pMod->fNative
9587	&& pMod->u.Manual.enmState != KWMODSTATE_NEEDS_BITS)
9588	{
9589	KSIZE iImp;
9590	pMod->u.Manual.enmState = KWMODSTATE_NEEDS_BITS;
9591	iImp = pMod->u.Manual.cImpMods;
9592	while (iImp-- > 0)
9593	kwSandboxResetModuleState(pMod->u.Manual.apImpMods[iImp]);
9594	}
9595	}
9596
9597	static PPEB kwSandboxGetProcessEnvironmentBlock(void)
9598	{
9599	#if K_ARCH == K_ARCH_X86_32
9600	return (PPEB)__readfsdword(0x030 /* offset of ProcessEnvironmentBlock in TEB */);
9601	#elif K_ARCH == K_ARCH_AMD64
9602	return (PPEB)__readgsqword(0x060 /* offset of ProcessEnvironmentBlock in TEB */);
9603	#else
9604	# error "Port me!"
9605	#endif
9606	}
9607
9608
9609	/**
9610	* Enters the given handle into the handle table.
9611	*
9612	* @returns K_TRUE on success, K_FALSE on failure.
9613	* @param pSandbox The sandbox.
9614	* @param pHandle The handle.
9615	* @param hHandle The handle value to enter it under (for the
9616	* duplicate handle API).
9617	*/
9618	static KBOOL kwSandboxHandleTableEnter(PKWSANDBOX pSandbox, PKWHANDLE pHandle, HANDLE hHandle)
9619	{
9620	KUPTR const idxHandle = KW_HANDLE_TO_INDEX(hHandle);
9621	kHlpAssertReturn(idxHandle < KW_HANDLE_MAX, K_FALSE);
9622
9623	/*
9624	* Grow handle table.
9625	*/
9626	if (idxHandle >= pSandbox->cHandles)
9627	{
9628	void *pvNew;
9629	KU32 cHandles = pSandbox->cHandles ? pSandbox->cHandles * 2 : 32;
9630	while (cHandles <= idxHandle)
9631	cHandles *= 2;
9632	pvNew = kHlpRealloc(pSandbox->papHandles, cHandles * sizeof(pSandbox->papHandles[0]));
9633	if (!pvNew)
9634	{
9635	KW_LOG(("Out of memory growing handle table to %u handles\n", cHandles));
9636	return K_FALSE;
9637	}
9638	pSandbox->papHandles = (PKWHANDLE *)pvNew;
9639	kHlpMemSet(&pSandbox->papHandles[pSandbox->cHandles], 0,
9640	(cHandles - pSandbox->cHandles) * sizeof(pSandbox->papHandles[0]));
9641	pSandbox->cHandles = cHandles;
9642	}
9643
9644	/*
9645	* Check that the entry is unused then insert it.
9646	*/
9647	kHlpAssertReturn(pSandbox->papHandles[idxHandle] == NULL, K_FALSE);
9648	pSandbox->papHandles[idxHandle] = pHandle;
9649	pSandbox->cActiveHandles++;
9650	return K_TRUE;
9651	}
9652
9653
9654	/**
9655	* Creates a correctly quoted ANSI command line string from the given argv.
9656	*
9657	* @returns Pointer to the command line.
9658	* @param cArgs Number of arguments.
9659	* @param papszArgs The argument vector.
9660	* @param fWatcomBrainDamange Whether to apply watcom rules while quoting.
9661	* @param pcbCmdLine Where to return the command line length,
9662	* including one terminator.
9663	*/
9664	static char kwSandboxInitCmdLineFromArgv(KU32 cArgs, const char papszArgs, KBOOL fWatcomBrainDamange, KSIZE pcbCmdLine)
9665	{
9666	KU32 i;
9667	KSIZE cbCmdLine;
9668	char *pszCmdLine;
9669
9670	/* Make a copy of the argument vector that we'll be quoting. */
9671	char *papszQuotedArgs = alloca(sizeof(papszArgs[0]) (cArgs + 1));
9672	kHlpMemCopy(papszQuotedArgs, papszArgs, sizeof(papszArgs[0]) * (cArgs + 1));
9673
9674	/* Quote the arguments that need it. */
9675	quote_argv(cArgs, papszQuotedArgs, fWatcomBrainDamange, 0 /leak/);
9676
9677	/* figure out cmd line length. */
9678	cbCmdLine = 0;
9679	for (i = 0; i < cArgs; i++)
9680	cbCmdLine += kHlpStrLen(papszQuotedArgs[i]) + 1;
9681	*pcbCmdLine = cbCmdLine;
9682
9683	pszCmdLine = (char *)kHlpAlloc(cbCmdLine + 1);
9684	if (pszCmdLine)
9685	{
9686	char *psz = kHlpStrPCopy(pszCmdLine, papszQuotedArgs[0]);
9687	if (papszQuotedArgs[0] != papszArgs[0])
9688	free(papszQuotedArgs[0]);
9689
9690	for (i = 1; i < cArgs; i++)
9691	{
9692	*psz++ = ' ';
9693	psz = kHlpStrPCopy(psz, papszQuotedArgs[i]);
9694	if (papszQuotedArgs[i] != papszArgs[i])
9695	free(papszQuotedArgs[i]);
9696	}
9697	kHlpAssert((KSIZE)(&psz[1] - pszCmdLine) == cbCmdLine);
9698
9699	*psz++ = '\0';
9700	*psz++ = '\0';
9701	}
9702
9703	return pszCmdLine;
9704	}
9705
9706
9707
9708	static int kwSandboxInit(PKWSANDBOX pSandbox, PKWTOOL pTool,
9709	KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
9710	KU32 cEnvVars, const char **papszEnvVars, KBOOL fNoPchCaching)
9711	{
9712	PPEB pPeb = kwSandboxGetProcessEnvironmentBlock();
9713	PMY_RTL_USER_PROCESS_PARAMETERS pProcParams = (PMY_RTL_USER_PROCESS_PARAMETERS)pPeb->ProcessParameters;
9714	wchar_t *pwcPool;
9715	KSIZE cbStrings;
9716	KSIZE cwc;
9717	KSIZE cbCmdLine;
9718	KU32 i;
9719
9720	/* Simple stuff. */
9721	pSandbox->rcExitCode = 256;
9722	pSandbox->pTool = pTool;
9723	pSandbox->idMainThread = GetCurrentThreadId();
9724	pSandbox->pgmptr = (char *)pTool->pszPath;
9725	pSandbox->wpgmptr = (wchar_t *)pTool->pwszPath;
9726	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
9727	if (pSandbox->StdOut.fIsConsole)
9728	pSandbox->StdOut.u.Con.cwcBuf = 0;
9729	else
9730	pSandbox->StdOut.u.Fully.cchBuf = 0;
9731	if (pSandbox->StdErr.fIsConsole)
9732	pSandbox->StdErr.u.Con.cwcBuf = 0;
9733	else
9734	pSandbox->StdErr.u.Fully.cchBuf = 0;
9735	pSandbox->Combined.cwcBuf = 0;
9736	pSandbox->Combined.cFlushes = 0;
9737	#endif
9738	pSandbox->fNoPchCaching = fNoPchCaching;
9739	pSandbox->cArgs = cArgs;
9740	pSandbox->papszArgs = (char **)papszArgs;
9741	pSandbox->pszCmdLine = kwSandboxInitCmdLineFromArgv(cArgs, papszArgs, fWatcomBrainDamange, &cbCmdLine);
9742	if (!pSandbox->pszCmdLine)
9743	return KERR_NO_MEMORY;
9744
9745	/*
9746	* Convert command line and argv to UTF-16.
9747	* We assume each ANSI char requires a surrogate pair in the UTF-16 variant.
9748	*/
9749	pSandbox->papwszArgs = (wchar_t *)kHlpAlloc(sizeof(wchar_t ) * (pSandbox->cArgs + 2) + cbCmdLine * 2 * sizeof(wchar_t));
9750	if (!pSandbox->papwszArgs)
9751	return KERR_NO_MEMORY;
9752	pwcPool = (wchar_t *)&pSandbox->papwszArgs[pSandbox->cArgs + 2];
9753	for (i = 0; i < cArgs; i++)
9754	{
9755	pwcPool++ = pSandbox->papszArgs[i][-1]; / flags */
9756	pSandbox->papwszArgs[i] = pwcPool;
9757	pwcPool += kwStrToUtf16(pSandbox->papszArgs[i], pwcPool, (kHlpStrLen(pSandbox->papszArgs[i]) + 1) * 2);
9758	pwcPool++;
9759	}
9760	pSandbox->papwszArgs[pSandbox->cArgs + 0] = NULL;
9761	pSandbox->papwszArgs[pSandbox->cArgs + 1] = NULL;
9762
9763	/*
9764	* Convert the commandline string to UTF-16, same pessimistic approach as above.
9765	*/
9766	cbStrings = (cbCmdLine + 1) * 2 * sizeof(wchar_t);
9767	pSandbox->pwszCmdLine = kHlpAlloc(cbStrings);
9768	if (!pSandbox->pwszCmdLine)
9769	return KERR_NO_MEMORY;
9770	cwc = kwStrToUtf16(pSandbox->pszCmdLine, pSandbox->pwszCmdLine, cbStrings / sizeof(wchar_t));
9771
9772	pSandbox->SavedCommandLine = pProcParams->CommandLine;
9773	pProcParams->CommandLine.Buffer = pSandbox->pwszCmdLine;
9774	pProcParams->CommandLine.Length = (USHORT)cwc * sizeof(wchar_t);
9775
9776	/*
9777	* Setup the environment.
9778	*/
9779	if ( cEnvVars + 2 <= pSandbox->cEnvVarsAllocated
9780	\|\| kwSandboxGrowEnv(pSandbox, cEnvVars + 2) == 0)
9781	{
9782	KU32 iDst = 0;
9783	for (i = 0; i < cEnvVars; i++)
9784	{
9785	const char *pszVar = papszEnvVars[i];
9786	KSIZE cchVar = kHlpStrLen(pszVar);
9787	const char *pszEqual;
9788	if ( cchVar > 0
9789	&& (pszEqual = kHlpMemChr(pszVar, '=', cchVar)) != NULL)
9790	{
9791	char *pszCopy = kHlpDup(pszVar, cchVar + 1);
9792	wchar_t *pwszCopy = kwStrToUtf16AllocN(pszVar, cchVar + 1);
9793	if (pszCopy && pwszCopy)
9794	{
9795	pSandbox->papszEnvVars[iDst] = pszCopy;
9796	pSandbox->environ[iDst] = pszCopy;
9797	pSandbox->papwszEnvVars[iDst] = pwszCopy;
9798	pSandbox->wenviron[iDst] = pwszCopy;
9799
9800	/* When we see the path, we must tell the system or native exec and module loading won't work . */
9801	if ( (pszEqual - pszVar) == 4
9802	&& ( pszCopy[0] == 'P' \|\| pszCopy[0] == 'p')
9803	&& ( pszCopy[1] == 'A' \|\| pszCopy[1] == 'a')
9804	&& ( pszCopy[2] == 'T' \|\| pszCopy[2] == 't')
9805	&& ( pszCopy[3] == 'H' \|\| pszCopy[3] == 'h'))
9806	if (!SetEnvironmentVariableW(L"Path", &pwszCopy[5]))
9807	kwErrPrintf("kwSandboxInit: SetEnvironmentVariableW(Path,) failed: %u\n", GetLastError());
9808
9809	iDst++;
9810	}
9811	else
9812	{
9813	kHlpFree(pszCopy);
9814	kHlpFree(pwszCopy);
9815	return kwErrPrintfRc(KERR_NO_MEMORY, "Out of memory setting up env vars!\n");
9816	}
9817	}
9818	else
9819	kwErrPrintf("kwSandboxInit: Skipping bad env var '%s'\n", pszVar);
9820	}
9821	pSandbox->papszEnvVars[iDst] = NULL;
9822	pSandbox->environ[iDst] = NULL;
9823	pSandbox->papwszEnvVars[iDst] = NULL;
9824	pSandbox->wenviron[iDst] = NULL;
9825	}
9826	else
9827	return kwErrPrintfRc(KERR_NO_MEMORY, "Error setting up environment variables: kwSandboxGrowEnv failed\n");
9828
9829	/*
9830	* Invalidate the volatile parts of cache (kBuild output directory,
9831	* temporary directory, whatever).
9832	*/
9833	kFsCacheInvalidateCustomBoth(g_pFsCache);
9834
9835	#ifdef WITH_HISTORY
9836	/*
9837	* Record command line in debug history.
9838	*/
9839	kHlpFree(g_apszHistory[g_iHistoryNext]);
9840	g_apszHistory[g_iHistoryNext] = kHlpStrDup(pSandbox->pszCmdLine);
9841	g_iHistoryNext = (g_iHistoryNext + 1) % K_ELEMENTS(g_apszHistory);
9842	#endif
9843
9844	return 0;
9845	}
9846
9847
9848	/**
9849	* Does sandbox cleanup between jobs.
9850	*
9851	* We postpone whatever isn't externally visible (i.e. files) and doesn't
9852	* influence the result, so that kmk can get on with things ASAP.
9853	*
9854	* @param pSandbox The sandbox.
9855	*/
9856	static void kwSandboxCleanupLate(PKWSANDBOX pSandbox)
9857	{
9858	PROCESS_MEMORY_COUNTERS MemInfo;
9859	PKWVIRTALLOC pTracker;
9860	PKWHEAP pHeap;
9861	PKWLOCALSTORAGE pLocalStorage;
9862	#ifdef WITH_HASH_MD5_CACHE
9863	PKWHASHMD5 pHash;
9864	#endif
9865	#ifdef WITH_TEMP_MEMORY_FILES
9866	PKWFSTEMPFILE pTempFile;
9867	#endif
9868	PKWEXITCALLACK pExitCallback;
9869
9870	/*
9871	* First stuff that may cause code to run.
9872	*/
9873
9874	/* Do exit callback first. */
9875	pExitCallback = g_Sandbox.pExitCallbackHead;
9876	g_Sandbox.pExitCallbackHead = NULL;
9877	while (pExitCallback)
9878	{
9879	PKWEXITCALLACK pNext = pExitCallback->pNext;
9880	KW_LOG(("kwSandboxCleanupLate: calling %p %sexit handler\n",
9881	pExitCallback->pfnCallback, pExitCallback->fAtExit ? "at" : "_on"));
9882	__try
9883	{
9884	pExitCallback->pfnCallback();
9885	}
9886	__except (EXCEPTION_EXECUTE_HANDLER)
9887	{
9888	KW_LOG(("kwSandboxCleanupLate: %sexit handler %p threw an exception!\n",
9889	pExitCallback->fAtExit ? "at" : "_on", pExitCallback->pfnCallback));
9890	kHlpAssertFailed();
9891	}
9892	kHlpFree(pExitCallback);
9893	pExitCallback = pNext;
9894	}
9895
9896	/* Free left behind FlsAlloc leaks. */
9897	pLocalStorage = g_Sandbox.pFlsAllocHead;
9898	g_Sandbox.pFlsAllocHead = NULL;
9899	while (pLocalStorage)
9900	{
9901	PKWLOCALSTORAGE pNext = pLocalStorage->pNext;
9902	KW_LOG(("Freeing leaked FlsAlloc index %#x\n", pLocalStorage->idx));
9903	FlsFree(pLocalStorage->idx);
9904	kHlpFree(pLocalStorage);
9905	pLocalStorage = pNext;
9906	}
9907
9908	/* Free left behind TlsAlloc leaks. */
9909	pLocalStorage = g_Sandbox.pTlsAllocHead;
9910	g_Sandbox.pTlsAllocHead = NULL;
9911	while (pLocalStorage)
9912	{
9913	PKWLOCALSTORAGE pNext = pLocalStorage->pNext;
9914	KW_LOG(("Freeing leaked TlsAlloc index %#x\n", pLocalStorage->idx));
9915	TlsFree(pLocalStorage->idx);
9916	kHlpFree(pLocalStorage);
9917	pLocalStorage = pNext;
9918	}
9919
9920
9921	/*
9922	* Then free resources associated with the sandbox run.
9923	*/
9924
9925	/* Open handles, except fixed handles (stdout and stderr). */
9926	if (pSandbox->cActiveHandles > pSandbox->cFixedHandles)
9927	{
9928	KU32 idxHandle = pSandbox->cHandles;
9929	while (idxHandle-- > 0)
9930	if (pSandbox->papHandles[idxHandle] == NULL)
9931	{ /* likely */ }
9932	else
9933	{
9934	PKWHANDLE pHandle = pSandbox->papHandles[idxHandle];
9935	if ( pHandle->enmType != KWHANDLETYPE_OUTPUT_BUF
9936	\|\| idxHandle != KW_HANDLE_TO_INDEX(pHandle->hHandle) )
9937	{
9938	pSandbox->papHandles[idxHandle] = NULL;
9939	pSandbox->cLeakedHandles++;
9940
9941	switch (pHandle->enmType)
9942	{
9943	case KWHANDLETYPE_FSOBJ_READ_CACHE:
9944	KWFS_LOG(("Closing leaked read cache handle: %#x/%p cRefs=%d\n",
9945	idxHandle, pHandle->hHandle, pHandle->cRefs));
9946	break;
9947	case KWHANDLETYPE_FSOBJ_READ_CACHE_MAPPING:
9948	KWFS_LOG(("Closing leaked read mapping handle: %#x/%p cRefs=%d\n",
9949	idxHandle, pHandle->hHandle, pHandle->cRefs));
9950	break;
9951	case KWHANDLETYPE_OUTPUT_BUF:
9952	KWFS_LOG(("Closing leaked output buf handle: %#x/%p cRefs=%d\n",
9953	idxHandle, pHandle->hHandle, pHandle->cRefs));
9954	break;
9955	case KWHANDLETYPE_TEMP_FILE:
9956	KWFS_LOG(("Closing leaked temp file handle: %#x/%p cRefs=%d\n",
9957	idxHandle, pHandle->hHandle, pHandle->cRefs));
9958	pHandle->u.pTempFile->cActiveHandles--;
9959	break;
9960	case KWHANDLETYPE_TEMP_FILE_MAPPING:
9961	KWFS_LOG(("Closing leaked temp mapping handle: %#x/%p cRefs=%d\n",
9962	idxHandle, pHandle->hHandle, pHandle->cRefs));
9963	pHandle->u.pTempFile->cActiveHandles--;
9964	break;
9965	default:
9966	kHlpAssertFailed();
9967	}
9968	if (--pHandle->cRefs == 0)
9969	kHlpFree(pHandle);
9970	if (--pSandbox->cActiveHandles == pSandbox->cFixedHandles)
9971	break;
9972	}
9973	}
9974	kHlpAssert(pSandbox->cActiveHandles == pSandbox->cFixedHandles);
9975	}
9976
9977	/* Reset memory mappings - This assumes none of the DLLs keeps any of our mappings open! */
9978	g_Sandbox.cMemMappings = 0;
9979
9980	#ifdef WITH_TEMP_MEMORY_FILES
9981	/* The temporary files aren't externally visible, they're all in memory. */
9982	pTempFile = pSandbox->pTempFileHead;
9983	pSandbox->pTempFileHead = NULL;
9984	while (pTempFile)
9985	{
9986	PKWFSTEMPFILE pNext = pTempFile->pNext;
9987	KU32 iSeg = pTempFile->cSegs;
9988	while (iSeg-- > 0)
9989	kHlpPageFree(pTempFile->paSegs[iSeg].pbData, pTempFile->paSegs[iSeg].cbDataAlloc);
9990	kHlpFree(pTempFile->paSegs);
9991	pTempFile->pNext = NULL;
9992	kHlpFree(pTempFile);
9993
9994	pTempFile = pNext;
9995	}
9996	#endif
9997
9998	/* Free left behind HeapCreate leaks. */
9999	pHeap = g_Sandbox.pHeapHead;
10000	g_Sandbox.pHeapHead = NULL;
10001	while (pHeap != NULL)
10002	{
10003	PKWHEAP pNext = pHeap->pNext;
10004	KW_LOG(("Freeing HeapCreate leak %p\n", pHeap->hHeap));
10005	HeapDestroy(pHeap->hHeap);
10006	pHeap = pNext;
10007	}
10008
10009	/* Free left behind VirtualAlloc leaks. */
10010	pTracker = g_Sandbox.pVirtualAllocHead;
10011	g_Sandbox.pVirtualAllocHead = NULL;
10012	while (pTracker)
10013	{
10014	PKWVIRTALLOC pNext = pTracker->pNext;
10015	KW_LOG(("Freeing VirtualFree leak %p LB %#x\n", pTracker->pvAlloc, pTracker->cbAlloc));
10016
10017	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
10018	if (pTracker->idxPreAllocated != KU32_MAX)
10019	kwSandboxResetFixedAllocation(pTracker->idxPreAllocated);
10020	else
10021	#endif
10022	VirtualFree(pTracker->pvAlloc, 0, MEM_RELEASE);
10023	kHlpFree(pTracker);
10024	pTracker = pNext;
10025	}
10026
10027	/* Free the environment. */
10028	if (pSandbox->papszEnvVars)
10029	{
10030	KU32 i;
10031	for (i = 0; pSandbox->papszEnvVars[i]; i++)
10032	kHlpFree(pSandbox->papszEnvVars[i]);
10033	pSandbox->environ[0] = NULL;
10034	pSandbox->papszEnvVars[0] = NULL;
10035
10036	for (i = 0; pSandbox->papwszEnvVars[i]; i++)
10037	kHlpFree(pSandbox->papwszEnvVars[i]);
10038	pSandbox->wenviron[0] = NULL;
10039	pSandbox->papwszEnvVars[0] = NULL;
10040	}
10041
10042	#ifdef WITH_HASH_MD5_CACHE
10043	/*
10044	* Hash handles.
10045	*/
10046	pHash = pSandbox->pHashHead;
10047	pSandbox->pHashHead = NULL;
10048	while (pHash)
10049	{
10050	PKWHASHMD5 pNext = pHash->pNext;
10051	KWCRYPT_LOG(("Freeing leaked hash instance %#p\n", pHash));
10052	kHlpFree(pHash);
10053	pHash = pNext;
10054	}
10055	#endif
10056
10057	/*
10058	* Check the memory usage. If it's getting high, trigger a respawn
10059	* after the next job.
10060	*/
10061	MemInfo.WorkingSetSize = 0;
10062	if (GetProcessMemoryInfo(GetCurrentProcess(), &MemInfo, sizeof(MemInfo)))
10063	{
10064	/* The first time thru, we figure out approximately when to restart
10065	based on installed RAM and CPU threads. */
10066	static KU64 s_cbMaxWorkingSet = 0;
10067	if (s_cbMaxWorkingSet != 0)
10068	{ /* likely */ }
10069	else
10070	{
10071	SYSTEM_INFO SysInfo;
10072	MEMORYSTATUSEX GlobalMemInfo;
10073	const char *pszValue;
10074
10075	/* Calculate a reasonable estimate. */
10076	kHlpMemSet(&SysInfo, 0, sizeof(SysInfo));
10077	GetNativeSystemInfo(&SysInfo);
10078
10079	kHlpMemSet(&GlobalMemInfo, 0, sizeof(GlobalMemInfo));
10080	GlobalMemInfo.dwLength = sizeof(GlobalMemInfo);
10081	if (!GlobalMemoryStatusEx(&GlobalMemInfo))
10082	#if K_ARCH_BITS >= 64
10083	GlobalMemInfo.ullTotalPhys = KU64_C(0x000200000000); /* 8GB */
10084	#else
10085	GlobalMemInfo.ullTotalPhys = KU64_C(0x000080000000); /* 2GB */
10086	#endif
10087	s_cbMaxWorkingSet = GlobalMemInfo.ullTotalPhys / (K_MAX(SysInfo.dwNumberOfProcessors, 1) * 4);
10088	KW_LOG(("Raw estimate of s_cbMaxWorkingSet=%" KU64_PRI "\n", s_cbMaxWorkingSet));
10089
10090	/* User limit. */
10091	pszValue = getenv("KWORKER_MEMORY_LIMIT");
10092	if (pszValue != NULL)
10093	{
10094	char *pszNext;
10095	unsigned long ulValue = strtol(pszValue, &pszNext, 0);
10096	if (pszNext == '\0' \|\| pszNext == 'M')
10097	s_cbMaxWorkingSet = ulValue * (KU64)1048576;
10098	else if (*pszNext == 'K')
10099	s_cbMaxWorkingSet = ulValue * (KU64)1024;
10100	else if (*pszNext == 'G')
10101	s_cbMaxWorkingSet = ulValue * (KU64)1073741824;
10102	else
10103	kwErrPrintf("Unable to grok KWORKER_MEMORY_LIMIT: %s\n", pszValue);
10104	KW_LOG(("User s_cbMaxWorkingSet=%" KU64_PRI "\n", s_cbMaxWorkingSet));
10105	}
10106
10107	/* Clamp it a little. */
10108	if (s_cbMaxWorkingSet < 16810241024)
10109	s_cbMaxWorkingSet = 16810241024;
10110	#if K_ARCH_BITS < 64
10111	else
10112	s_cbMaxWorkingSet = K_MIN(s_cbMaxWorkingSet,
10113	SysInfo.dwProcessorType != PROCESSOR_ARCHITECTURE_AMD64
10114	? 51210241024 /* Only got 2 or 3 GB VA */
10115	: 153610241024 /* got 4GB VA */);
10116	#endif
10117	if (s_cbMaxWorkingSet > GlobalMemInfo.ullTotalPhys)
10118	s_cbMaxWorkingSet = GlobalMemInfo.ullTotalPhys;
10119	KW_LOG(("Final s_cbMaxWorkingSet=%" KU64_PRI "\n", s_cbMaxWorkingSet));
10120	}
10121
10122	/* Finally the check. */
10123	if (MemInfo.WorkingSetSize >= s_cbMaxWorkingSet)
10124	{
10125	KW_LOG(("WorkingSetSize = %#x - > restart next time.\n", MemInfo.WorkingSetSize));
10126	g_fRestart = K_TRUE;
10127	}
10128	}
10129
10130	/*
10131	* The CRT has a max of 8192 handles, so we better restart after a while if
10132	* someone is leaking handles or we risk running out of descriptors.
10133	*
10134	* Note! We only detect leaks for handles we intercept. In the case of CL.EXE
10135	* doing _dup2(1, 2) (stderr ==> stdout), there isn't actually a leak.
10136	*/
10137	if (pSandbox->cLeakedHandles > 6000)
10138	{
10139	KW_LOG(("LeakedHandles = %#x - > restart next time.\n", pSandbox->cLeakedHandles));
10140	g_fRestart = K_TRUE;
10141	}
10142	}
10143
10144
10145	/**
10146	* Does essential cleanups and restoring, anything externally visible.
10147	*
10148	* All cleanups that aren't externally visible are postponed till after we've
10149	* informed kmk of the result, so it can be done in the dead time between jobs.
10150	*
10151	* @param pSandbox The sandbox.
10152	*/
10153	static void kwSandboxCleanup(PKWSANDBOX pSandbox)
10154	{
10155	/*
10156	* Restore the parent command line string.
10157	*/
10158	PPEB pPeb = kwSandboxGetProcessEnvironmentBlock();
10159	PMY_RTL_USER_PROCESS_PARAMETERS pProcParams = (PMY_RTL_USER_PROCESS_PARAMETERS)pPeb->ProcessParameters;
10160	pProcParams->CommandLine = pSandbox->SavedCommandLine;
10161	pProcParams->StandardOutput = pSandbox->StdOut.hOutput;
10162	pProcParams->StandardError = pSandbox->StdErr.hOutput; /* CL.EXE messes with this one. */
10163	}
10164
10165
10166	static int kwSandboxExec(PKWSANDBOX pSandbox, PKWTOOL pTool, KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
10167	KU32 cEnvVars, const char **papszEnvVars, KBOOL fNoPchCaching)
10168	{
10169	int rcExit = 42;
10170	int rc;
10171
10172	/*
10173	* Initialize the sandbox environment.
10174	*/
10175	rc = kwSandboxInit(&g_Sandbox, pTool, cArgs, papszArgs, fWatcomBrainDamange, cEnvVars, papszEnvVars, fNoPchCaching);
10176	if (rc == 0)
10177	{
10178	/*
10179	* Do module initialization.
10180	*/
10181	kwSandboxResetModuleState(pTool->u.Sandboxed.pExe);
10182	rc = kwLdrModuleInitTree(pTool->u.Sandboxed.pExe);
10183	if (rc == 0)
10184	{
10185	/*
10186	* Call the main function.
10187	*/
10188	#if K_ARCH == K_ARCH_AMD64
10189	int (pfnWin64Entrypoint)(void pvPeb, void , void , void *);
10190	#elif K_ARCH == K_ARCH_X86_32
10191	int (__cdecl pfnWin32Entrypoint)(void pvPeb);
10192	#else
10193	# error "Port me!"
10194	#endif
10195
10196	/* Save the NT TIB first (should do that here, not in some other function). */
10197	PNT_TIB pTib = (PNT_TIB)NtCurrentTeb();
10198	pSandbox->TibMainThread = *pTib;
10199
10200	/* Make the call in a guarded fashion. */
10201	#if K_ARCH == K_ARCH_AMD64
10202	/* AMD64 */
10203	(KUPTR )&pfnWin64Entrypoint = pTool->u.Sandboxed.uMainAddr;
10204	__try
10205	{
10206	pSandbox->pOutXcptListHead = pTib->ExceptionList;
10207	if (setjmp(pSandbox->JmpBuf) == 0)
10208	{
10209	(KU64)(pSandbox->JmpBuf) = 0; /** @todo find other way to prevent longjmp from doing unwind! */
10210	pSandbox->fRunning = K_TRUE;
10211	rcExit = pfnWin64Entrypoint(kwSandboxGetProcessEnvironmentBlock(), NULL, NULL, NULL);
10212	pSandbox->fRunning = K_FALSE;
10213	}
10214	else
10215	rcExit = pSandbox->rcExitCode;
10216	}
10217	#elif K_ARCH == K_ARCH_X86_32
10218	/* x86 (see _tmainCRTStartup) */
10219	(KUPTR )&pfnWin32Entrypoint = pTool->u.Sandboxed.uMainAddr;
10220	__try
10221	{
10222	pSandbox->pOutXcptListHead = pTib->ExceptionList;
10223	if (setjmp(pSandbox->JmpBuf) == 0)
10224	{
10225	//(KU64)(pSandbox->JmpBuf) = 0; /** @todo find other way to prevent longjmp from doing unwind! */
10226	pSandbox->fRunning = K_TRUE;
10227	rcExit = pfnWin32Entrypoint(kwSandboxGetProcessEnvironmentBlock());
10228	pSandbox->fRunning = K_FALSE;
10229	}
10230	else
10231	rcExit = pSandbox->rcExitCode;
10232	}
10233	#endif
10234	__except (EXCEPTION_EXECUTE_HANDLER)
10235	{
10236	kwErrPrintf("Caught exception %#x!\n", GetExceptionCode());
10237	#ifdef WITH_HISTORY
10238	{
10239	KU32 cPrinted = 0;
10240	while (cPrinted++ < 5)
10241	{
10242	KU32 idx = (g_iHistoryNext + K_ELEMENTS(g_apszHistory) - cPrinted) % K_ELEMENTS(g_apszHistory);
10243	if (g_apszHistory[idx])
10244	kwErrPrintf("cmd[%d]: %s\n", 1 - cPrinted, g_apszHistory[idx]);
10245	}
10246	}
10247	#endif
10248	rcExit = 512;
10249	}
10250	pSandbox->fRunning = K_FALSE;
10251
10252	/* Now, restore the NT TIB. */
10253	*pTib = pSandbox->TibMainThread;
10254	}
10255	else
10256	rcExit = 42 + 4;
10257
10258	/*
10259	* Flush and clean up the essential bits only, postpone whatever we
10260	* can till after we've replied to kmk.
10261	*/
10262	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
10263	kwSandboxConsoleFlushAll(&g_Sandbox);
10264	#endif
10265	kwSandboxCleanup(&g_Sandbox);
10266	}
10267	else
10268	rcExit = 42 + 3;
10269
10270	return rcExit;
10271	}
10272
10273
10274	/**
10275	* Does the post command part of a job (optional).
10276	*
10277	* @returns The exit code of the job.
10278	* @param cPostCmdArgs Number of post command arguments (includes cmd).
10279	* @param papszPostCmdArgs The post command and its argument.
10280	*/
10281	static int kSubmitHandleJobPostCmd(KU32 cPostCmdArgs, const char **papszPostCmdArgs)
10282	{
10283	const char *pszCmd = papszPostCmdArgs[0];
10284
10285	/* Allow the kmk builtin prefix. */
10286	static const char s_szKmkBuiltinPrefix[] = "kmk_builtin_";
10287	if (kHlpStrNComp(pszCmd, s_szKmkBuiltinPrefix, sizeof(s_szKmkBuiltinPrefix) - 1) == 0)
10288	pszCmd += sizeof(s_szKmkBuiltinPrefix) - 1;
10289
10290	/* Command switch. */
10291	if (kHlpStrComp(pszCmd, "kDepObj") == 0)
10292	{
10293	KMKBUILTINCTX Ctx = { papszPostCmdArgs[0], NULL };
10294	return kmk_builtin_kDepObj(cPostCmdArgs, (char **)papszPostCmdArgs, NULL, &Ctx);
10295	}
10296
10297	return kwErrPrintfRc(42 + 5 , "Unknown post command: '%s'\n", pszCmd);
10298	}
10299
10300
10301	/**
10302	* Part 2 of the "JOB" command handler.
10303	*
10304	* @returns The exit code of the job.
10305	* @param pszExecutable The executable to execute.
10306	* @param pszCwd The current working directory of the job.
10307	* @param cArgs The number of arguments.
10308	* @param papszArgs The argument vector.
10309	* @param fWatcomBrainDamange Whether to apply watcom rules while quoting.
10310	* @param cEnvVars The number of environment variables.
10311	* @param papszEnvVars The environment vector.
10312	* @param fNoPchCaching Whether to disable precompiled header file
10313	* caching. Avoid trouble when creating them.
10314	* @param cPostCmdArgs Number of post command arguments (includes cmd).
10315	* @param papszPostCmdArgs The post command and its argument.
10316	*/
10317	static int kSubmitHandleJobUnpacked(const char pszExecutable, const char pszCwd,
10318	KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
10319	KU32 cEnvVars, const char **papszEnvVars, KBOOL fNoPchCaching,
10320	KU32 cPostCmdArgs, const char **papszPostCmdArgs)
10321	{
10322	int rcExit;
10323	PKWTOOL pTool;
10324
10325	KW_LOG(("\n\nkSubmitHandleJobUnpacked: '%s' in '%s' cArgs=%u cEnvVars=%u cPostCmdArgs=%u\n",
10326	pszExecutable, pszCwd, cArgs, cEnvVars, cPostCmdArgs));
10327	#ifdef KW_LOG_ENABLED
10328	{
10329	KU32 i;
10330	for (i = 0; i < cArgs; i++)
10331	KW_LOG((" papszArgs[%u]=%s\n", i, papszArgs[i]));
10332	for (i = 0; i < cPostCmdArgs; i++)
10333	KW_LOG((" papszPostCmdArgs[%u]=%s\n", i, papszPostCmdArgs[i]));
10334	}
10335	#endif
10336	g_cJobs++;
10337
10338	/*
10339	* Lookup the tool.
10340	*/
10341	pTool = kwToolLookup(pszExecutable, cEnvVars, papszEnvVars);
10342	if (pTool)
10343	{
10344	/*
10345	* Change the directory if we're going to execute the job inside
10346	* this process. Then invoke the tool type specific handler.
10347	*/
10348	switch (pTool->enmType)
10349	{
10350	case KWTOOLTYPE_SANDBOXED:
10351	case KWTOOLTYPE_WATCOM:
10352	{
10353	/* Change dir. */
10354	KFSLOOKUPERROR enmError;
10355	PKFSOBJ pNewCurDir = kFsCacheLookupA(g_pFsCache, pszCwd, &enmError);
10356	if ( pNewCurDir == g_pCurDirObj
10357	&& pNewCurDir->bObjType == KFSOBJ_TYPE_DIR)
10358	kFsCacheObjRelease(g_pFsCache, pNewCurDir);
10359	else if (SetCurrentDirectoryA(pszCwd))
10360	{
10361	kFsCacheObjRelease(g_pFsCache, g_pCurDirObj);
10362	g_pCurDirObj = pNewCurDir;
10363	}
10364	else
10365	{
10366	kwErrPrintf("SetCurrentDirectory failed with %u on '%s'\n", GetLastError(), pszCwd);
10367	kFsCacheObjRelease(g_pFsCache, pNewCurDir);
10368	rcExit = 42 + 1;
10369	break;
10370	}
10371
10372	/* Call specific handler. */
10373	if (pTool->enmType == KWTOOLTYPE_SANDBOXED)
10374	{
10375	KW_LOG(("Sandboxing tool %s\n", pTool->pszPath));
10376	rcExit = kwSandboxExec(&g_Sandbox, pTool, cArgs, papszArgs, fWatcomBrainDamange,
10377	cEnvVars, papszEnvVars, fNoPchCaching);
10378	}
10379	else
10380	{
10381	kwErrPrintf("TODO: Watcom style tool %s\n", pTool->pszPath);
10382	rcExit = 42 + 2;
10383	}
10384	break;
10385	}
10386
10387	case KWTOOLTYPE_EXEC:
10388	kwErrPrintf("TODO: Direct exec tool %s\n", pTool->pszPath);
10389	rcExit = 42 + 2;
10390	break;
10391
10392	default:
10393	kHlpAssertFailed();
10394	kwErrPrintf("Internal tool type corruption!!\n");
10395	rcExit = 42 + 2;
10396	g_fRestart = K_TRUE;
10397	break;
10398	}
10399
10400	/*
10401	* Do the post command, if present.
10402	*/
10403	if (cPostCmdArgs && rcExit == 0)
10404	rcExit = kSubmitHandleJobPostCmd(cPostCmdArgs, papszPostCmdArgs);
10405	}
10406	else
10407	rcExit = 42 + 1;
10408	return rcExit;
10409	}
10410
10411
10412	/**
10413	* Handles a "JOB" command.
10414	*
10415	* @returns The exit code of the job.
10416	* @param pszMsg Points to the "JOB" command part of the message.
10417	* @param cbMsg Number of message bytes at @a pszMsg. There are
10418	* 4 more zero bytes after the message body to
10419	* simplify parsing.
10420	*/
10421	static int kSubmitHandleJob(const char *pszMsg, KSIZE cbMsg)
10422	{
10423	int rcExit = 42;
10424
10425	/*
10426	* Unpack the message.
10427	*/
10428	const char *pszExecutable;
10429	KSIZE cbTmp;
10430
10431	pszMsg += sizeof("JOB");
10432	cbMsg -= sizeof("JOB");
10433
10434	/* Executable name. */
10435	pszExecutable = pszMsg;
10436	cbTmp = kHlpStrLen(pszMsg) + 1;
10437	pszMsg += cbTmp;
10438	if ( cbTmp < cbMsg
10439	&& cbTmp > 2)
10440	{
10441	const char *pszCwd;
10442	cbMsg -= cbTmp;
10443
10444	/* Current working directory. */
10445	pszCwd = pszMsg;
10446	cbTmp = kHlpStrLen(pszMsg) + 1;
10447	pszMsg += cbTmp;
10448	if ( cbTmp + sizeof(KU32) < cbMsg
10449	&& cbTmp >= 2)
10450	{
10451	KU32 cArgs;
10452	cbMsg -= cbTmp;
10453
10454	/* Argument count. */
10455	kHlpMemCopy(&cArgs, pszMsg, sizeof(cArgs));
10456	pszMsg += sizeof(cArgs);
10457	cbMsg -= sizeof(cArgs);
10458
10459	if (cArgs > 0 && cArgs < 4096)
10460	{
10461	/* The argument vector. */
10462	char const *papszArgs = kHlpAlloc((cArgs + 1) sizeof(papszArgs[0]));
10463	if (papszArgs)
10464	{
10465	KU32 i;
10466	for (i = 0; i < cArgs; i++)
10467	{
10468	papszArgs[i] = pszMsg + 1; /* First byte is expansion flags for MSC & EMX. */
10469	cbTmp = 1 + kHlpStrLen(pszMsg + 1) + 1;
10470	pszMsg += cbTmp;
10471	if (cbTmp < cbMsg)
10472	cbMsg -= cbTmp;
10473	else
10474	{
10475	cbMsg = 0;
10476	break;
10477	}
10478
10479	}
10480	papszArgs[cArgs] = 0;
10481
10482	/* Environment variable count. */
10483	if (cbMsg > sizeof(KU32))
10484	{
10485	KU32 cEnvVars;
10486	kHlpMemCopy(&cEnvVars, pszMsg, sizeof(cEnvVars));
10487	pszMsg += sizeof(cEnvVars);
10488	cbMsg -= sizeof(cEnvVars);
10489
10490	if (cEnvVars >= 0 && cEnvVars < 4096)
10491	{
10492	/* The argument vector. */
10493	char const *papszEnvVars = kHlpAlloc((cEnvVars + 1) sizeof(papszEnvVars[0]));
10494	if (papszEnvVars)
10495	{
10496	for (i = 0; i < cEnvVars; i++)
10497	{
10498	papszEnvVars[i] = pszMsg;
10499	cbTmp = kHlpStrLen(pszMsg) + 1;
10500	pszMsg += cbTmp;
10501	if (cbTmp < cbMsg)
10502	cbMsg -= cbTmp;
10503	else
10504	{
10505	cbMsg = 0;
10506	break;
10507	}
10508	}
10509	papszEnvVars[cEnvVars] = 0;
10510
10511	/* Flags (currently just watcom argument brain damage and no precompiled header caching). */
10512	if (cbMsg >= sizeof(KU8) * 2)
10513	{
10514	KBOOL fWatcomBrainDamange = *pszMsg++;
10515	KBOOL fNoPchCaching = *pszMsg++;
10516	cbMsg -= 2;
10517
10518	/* Post command argument count (can be zero). */
10519	if (cbMsg >= sizeof(KU32))
10520	{
10521	KU32 cPostCmdArgs;
10522	kHlpMemCopy(&cPostCmdArgs, pszMsg, sizeof(cPostCmdArgs));
10523	pszMsg += sizeof(cPostCmdArgs);
10524	cbMsg -= sizeof(cPostCmdArgs);
10525
10526	if (cPostCmdArgs >= 0 && cPostCmdArgs < 32)
10527	{
10528	char const *apszPostCmdArgs[32+1];
10529	for (i = 0; i < cPostCmdArgs; i++)
10530	{
10531	apszPostCmdArgs[i] = pszMsg;
10532	cbTmp = kHlpStrLen(pszMsg) + 1;
10533	pszMsg += cbTmp;
10534	if ( cbTmp < cbMsg
10535	\|\| (cbTmp == cbMsg && i + 1 == cPostCmdArgs))
10536	cbMsg -= cbTmp;
10537	else
10538	{
10539	cbMsg = KSIZE_MAX;
10540	break;
10541	}
10542	}
10543	if (cbMsg == 0)
10544	{
10545	apszPostCmdArgs[cPostCmdArgs] = NULL;
10546
10547	/*
10548	* The next step.
10549	*/
10550	rcExit = kSubmitHandleJobUnpacked(pszExecutable, pszCwd,
10551	cArgs, papszArgs, fWatcomBrainDamange,
10552	cEnvVars, papszEnvVars, fNoPchCaching,
10553	cPostCmdArgs, apszPostCmdArgs);
10554	}
10555	else if (cbMsg == KSIZE_MAX)
10556	kwErrPrintf("Detected bogus message unpacking post command and its arguments!\n");
10557	else
10558	kwErrPrintf("Message has %u bytes unknown trailing bytes\n", cbMsg);
10559	}
10560	else
10561	kwErrPrintf("Bogus post command argument count: %u %#x\n", cPostCmdArgs, cPostCmdArgs);
10562	}
10563	else
10564	kwErrPrintf("Detected bogus message looking for the post command argument count!\n");
10565	}
10566	else
10567	kwErrPrintf("Detected bogus message unpacking environment variables!\n");
10568	kHlpFree((void *)papszEnvVars);
10569	}
10570	else
10571	kwErrPrintf("Error allocating papszEnvVars for %u variables\n", cEnvVars);
10572	}
10573	else
10574	kwErrPrintf("Bogus environment variable count: %u (%#x)\n", cEnvVars, cEnvVars);
10575	}
10576	else
10577	kwErrPrintf("Detected bogus message unpacking arguments and environment variable count!\n");
10578	kHlpFree((void *)papszArgs);
10579	}
10580	else
10581	kwErrPrintf("Error allocating argv for %u arguments\n", cArgs);
10582	}
10583	else
10584	kwErrPrintf("Bogus argument count: %u (%#x)\n", cArgs, cArgs);
10585	}
10586	else
10587	kwErrPrintf("Detected bogus message unpacking CWD path and argument count!\n");
10588	}
10589	else
10590	kwErrPrintf("Detected bogus message unpacking executable path!\n");
10591	return rcExit;
10592	}
10593
10594
10595	/**
10596	* Wrapper around WriteFile / write that writes the whole @a cbToWrite.
10597	*
10598	* @retval 0 on success.
10599	* @retval -1 on error (fully bitched).
10600	*
10601	* @param hPipe The pipe handle.
10602	* @param pvBuf The buffer to write out out.
10603	* @param cbToWrite The number of bytes to write.
10604	*/
10605	static int kSubmitWriteIt(HANDLE hPipe, const void *pvBuf, KU32 cbToWrite)
10606	{
10607	KU8 const pbBuf = (KU8 const )pvBuf;
10608	KU32 cbLeft = cbToWrite;
10609	for (;;)
10610	{
10611	DWORD cbActuallyWritten = 0;
10612	if (WriteFile(hPipe, pbBuf, cbLeft, &cbActuallyWritten, NULL /pOverlapped/))
10613	{
10614	cbLeft -= cbActuallyWritten;
10615	if (!cbLeft)
10616	return 0;
10617	pbBuf += cbActuallyWritten;
10618	}
10619	else
10620	{
10621	DWORD dwErr = GetLastError();
10622	if (cbLeft == cbToWrite)
10623	kwErrPrintf("WriteFile failed: %u\n", dwErr);
10624	else
10625	kwErrPrintf("WriteFile failed %u byte(s) in: %u\n", cbToWrite - cbLeft, dwErr);
10626	return -1;
10627	}
10628	}
10629	}
10630
10631
10632	/**
10633	* Wrapper around ReadFile / read that reads the whole @a cbToRead.
10634	*
10635	* @retval 0 on success.
10636	* @retval 1 on shut down (fShutdownOkay must be K_TRUE).
10637	* @retval -1 on error (fully bitched).
10638	* @param hPipe The pipe handle.
10639	* @param pvBuf The buffer to read into.
10640	* @param cbToRead The number of bytes to read.
10641	* @param fShutdownOkay Whether connection shutdown while reading the
10642	* first byte is okay or not.
10643	*/
10644	static int kSubmitReadIt(HANDLE hPipe, void *pvBuf, KU32 cbToRead, KBOOL fMayShutdown)
10645	{
10646	KU8 pbBuf = (KU8 )pvBuf;
10647	KU32 cbLeft = cbToRead;
10648	for (;;)
10649	{
10650	DWORD cbActuallyRead = 0;
10651	if (ReadFile(hPipe, pbBuf, cbLeft, &cbActuallyRead, NULL /pOverlapped/))
10652	{
10653	cbLeft -= cbActuallyRead;
10654	if (!cbLeft)
10655	return 0;
10656	pbBuf += cbActuallyRead;
10657	}
10658	else
10659	{
10660	DWORD dwErr = GetLastError();
10661	if (cbLeft == cbToRead)
10662	{
10663	if ( fMayShutdown
10664	&& dwErr == ERROR_BROKEN_PIPE)
10665	return 1;
10666	kwErrPrintf("ReadFile failed: %u\n", dwErr);
10667	}
10668	else
10669	kwErrPrintf("ReadFile failed %u byte(s) in: %u\n", cbToRead - cbLeft, dwErr);
10670	return -1;
10671	}
10672	}
10673	}
10674
10675
10676	/**
10677	* Decimal formatting of a 64-bit unsigned value into a large enough buffer.
10678	*
10679	* @returns pszBuf
10680	* @param pszBuf The buffer (sufficiently large).
10681	* @param uValue The value.
10682	*/
10683	static const char kwFmtU64(char pszBuf, KU64 uValue)
10684	{
10685	char szTmp[64];
10686	char *psz = &szTmp[63];
10687	int cch = 4;
10688
10689	*psz-- = '\0';
10690	do
10691	{
10692	if (--cch == 0)
10693	{
10694	*psz-- = ' ';
10695	cch = 3;
10696	}
10697	*psz-- = (uValue % 10) + '0';
10698	uValue /= 10;
10699	} while (uValue != 0);
10700
10701	return strcpy(pszBuf, psz + 1);
10702	}
10703
10704
10705	/**
10706	* Prints statistics.
10707	*/
10708	static void kwPrintStats(void)
10709	{
10710	PROCESS_MEMORY_COUNTERS_EX MemInfo;
10711	MEMORYSTATUSEX MemStatus;
10712	IO_COUNTERS IoCounters;
10713	DWORD cHandles;
10714	KSIZE cMisses;
10715	char szBuf[16*1024];
10716	int off = 0;
10717	char szPrf[24];
10718	char sz1[64];
10719	char sz2[64];
10720	char sz3[64];
10721	char sz4[64];
10722
10723	sprintf(szPrf, "%5d/%u:", getpid(), K_ARCH_BITS);
10724
10725	szBuf[off++] = '\n';
10726
10727	off += sprintf(&szBuf[off], "%s %14s jobs, %s tools, %s modules, %s non-native ones\n", szPrf,
10728	kwFmtU64(sz1, g_cJobs), kwFmtU64(sz2, g_cTools), kwFmtU64(sz3, g_cModules), kwFmtU64(sz4, g_cNonNativeModules));
10729	off += sprintf(&szBuf[off], "%s %14s bytes in %s read-cached files, avg %s bytes\n", szPrf,
10730	kwFmtU64(sz1, g_cbReadCachedFiles), kwFmtU64(sz2, g_cReadCachedFiles),
10731	kwFmtU64(sz3, g_cbReadCachedFiles / K_MAX(g_cReadCachedFiles, 1)));
10732
10733	off += sprintf(&szBuf[off], "%s %14s bytes read in %s calls\n",
10734	szPrf, kwFmtU64(sz1, g_cbReadFileTotal), kwFmtU64(sz2, g_cReadFileCalls));
10735
10736	off += sprintf(&szBuf[off], "%s %14s bytes read (%u%%) in %s calls (%u%%) from read cached files\n", szPrf,
10737	kwFmtU64(sz1, g_cbReadFileFromReadCached), (unsigned)(g_cbReadFileFromReadCached * (KU64)100 / g_cbReadFileTotal),
10738	kwFmtU64(sz2, g_cReadFileFromReadCached), (unsigned)(g_cReadFileFromReadCached * (KU64)100 / g_cReadFileCalls));
10739
10740	off += sprintf(&szBuf[off], "%s %14s bytes read (%u%%) in %s calls (%u%%) from in-memory temporary files\n", szPrf,
10741	kwFmtU64(sz1, g_cbReadFileFromInMemTemp), (unsigned)(g_cbReadFileFromInMemTemp * (KU64)100 / K_MAX(g_cbReadFileTotal, 1)),
10742	kwFmtU64(sz2, g_cReadFileFromInMemTemp), (unsigned)(g_cReadFileFromInMemTemp * (KU64)100 / K_MAX(g_cReadFileCalls, 1)));
10743
10744	off += sprintf(&szBuf[off], "%s %14s bytes written in %s calls\n", szPrf,
10745	kwFmtU64(sz1, g_cbWriteFileTotal), kwFmtU64(sz2, g_cWriteFileCalls));
10746	off += sprintf(&szBuf[off], "%s %14s bytes written (%u%%) in %s calls (%u%%) to in-memory temporary files\n", szPrf,
10747	kwFmtU64(sz1, g_cbWriteFileToInMemTemp),
10748	(unsigned)(g_cbWriteFileToInMemTemp * (KU64)100 / K_MAX(g_cbWriteFileTotal, 1)),
10749	kwFmtU64(sz2, g_cWriteFileToInMemTemp),
10750	(unsigned)(g_cWriteFileToInMemTemp * (KU64)100 / K_MAX(g_cWriteFileCalls, 1)));
10751
10752	off += sprintf(&szBuf[off], "%s %14s bytes for the cache\n", szPrf,
10753	kwFmtU64(sz1, g_pFsCache->cbObjects + g_pFsCache->cbAnsiPaths + g_pFsCache->cbUtf16Paths + sizeof(*g_pFsCache)));
10754	off += sprintf(&szBuf[off], "%s %14s objects, taking up %s bytes, avg %s bytes\n", szPrf,
10755	kwFmtU64(sz1, g_pFsCache->cObjects),
10756	kwFmtU64(sz2, g_pFsCache->cbObjects),
10757	kwFmtU64(sz3, g_pFsCache->cbObjects / g_pFsCache->cObjects));
10758	off += sprintf(&szBuf[off], "%s %14s A path hashes, taking up %s bytes, avg %s bytes, %s collision\n", szPrf,
10759	kwFmtU64(sz1, g_pFsCache->cAnsiPaths),
10760	kwFmtU64(sz2, g_pFsCache->cbAnsiPaths),
10761	kwFmtU64(sz3, g_pFsCache->cbAnsiPaths / K_MAX(g_pFsCache->cAnsiPaths, 1)),
10762	kwFmtU64(sz4, g_pFsCache->cAnsiPathCollisions));
10763	#ifdef KFSCACHE_CFG_UTF16
10764	off += sprintf(&szBuf[off], "%s %14s W path hashes, taking up %s bytes, avg %s bytes, %s collisions\n", szPrf,
10765	kwFmtU64(sz1, g_pFsCache->cUtf16Paths),
10766	kwFmtU64(sz2, g_pFsCache->cbUtf16Paths),
10767	kwFmtU64(sz3, g_pFsCache->cbUtf16Paths / K_MAX(g_pFsCache->cUtf16Paths, 1)),
10768	kwFmtU64(sz4, g_pFsCache->cUtf16PathCollisions));
10769	#endif
10770	off += sprintf(&szBuf[off], "%s %14s child hash tables, total of %s entries, %s children inserted, %s collisions\n", szPrf,
10771	kwFmtU64(sz1, g_pFsCache->cChildHashTabs),
10772	kwFmtU64(sz2, g_pFsCache->cChildHashEntriesTotal),
10773	kwFmtU64(sz3, g_pFsCache->cChildHashed),
10774	kwFmtU64(sz4, g_pFsCache->cChildHashCollisions));
10775
10776	cMisses = g_pFsCache->cLookups - g_pFsCache->cPathHashHits - g_pFsCache->cWalkHits;
10777	off += sprintf(&szBuf[off], "%s %14s lookups: %s (%u%%) path hash hits, %s (%u%%) walks hits, %s (%u%%) misses\n", szPrf,
10778	kwFmtU64(sz1, g_pFsCache->cLookups),
10779	kwFmtU64(sz2, g_pFsCache->cPathHashHits),
10780	(unsigned)(g_pFsCache->cPathHashHits * (KU64)100 / K_MAX(g_pFsCache->cLookups, 1)),
10781	kwFmtU64(sz3, g_pFsCache->cWalkHits),
10782	(unsigned)(g_pFsCache->cWalkHits * (KU64)100 / K_MAX(g_pFsCache->cLookups, 1)),
10783	kwFmtU64(sz4, cMisses),
10784	(unsigned)(cMisses * (KU64)100 / K_MAX(g_pFsCache->cLookups, 1)));
10785
10786	off += sprintf(&szBuf[off], "%s %14s child searches, %s (%u%%) hash hits\n", szPrf,
10787	kwFmtU64(sz1, g_pFsCache->cChildSearches),
10788	kwFmtU64(sz2, g_pFsCache->cChildHashHits),
10789	(unsigned)(g_pFsCache->cChildHashHits * (KU64)100 / K_MAX(g_pFsCache->cChildSearches, 1)));
10790	off += sprintf(&szBuf[off], "%s %14s name changes, growing %s times (%u%%)\n", szPrf,
10791	kwFmtU64(sz1, g_pFsCache->cNameChanges),
10792	kwFmtU64(sz2, g_pFsCache->cNameGrowths),
10793	(unsigned)(g_pFsCache->cNameGrowths * 100 / K_MAX(g_pFsCache->cNameChanges, 1)) );
10794
10795
10796	/*
10797	* Process & Memory details.
10798	*/
10799	if (!GetProcessHandleCount(GetCurrentProcess(), &cHandles))
10800	cHandles = 0;
10801	MemInfo.cb = sizeof(MemInfo);
10802	if (!GetProcessMemoryInfo(GetCurrentProcess(), (PPROCESS_MEMORY_COUNTERS)&MemInfo, sizeof(MemInfo)))
10803	memset(&MemInfo, 0, sizeof(MemInfo));
10804	off += sprintf(&szBuf[off], "%s %14s handles; %s page faults; %s bytes page file, peaking at %s bytes\n", szPrf,
10805	kwFmtU64(sz1, cHandles),
10806	kwFmtU64(sz2, MemInfo.PageFaultCount),
10807	kwFmtU64(sz3, MemInfo.PagefileUsage),
10808	kwFmtU64(sz4, MemInfo.PeakPagefileUsage));
10809	off += sprintf(&szBuf[off], "%s %14s bytes working set, peaking at %s bytes; %s byte private\n", szPrf,
10810	kwFmtU64(sz1, MemInfo.WorkingSetSize),
10811	kwFmtU64(sz2, MemInfo.PeakWorkingSetSize),
10812	kwFmtU64(sz3, MemInfo.PrivateUsage));
10813	off += sprintf(&szBuf[off], "%s %14s bytes non-paged pool, peaking at %s bytes; %s bytes paged pool, peaking at %s bytes\n",
10814	szPrf,
10815	kwFmtU64(sz1, MemInfo.QuotaNonPagedPoolUsage),
10816	kwFmtU64(sz2, MemInfo.QuotaPeakNonPagedPoolUsage),
10817	kwFmtU64(sz3, MemInfo.QuotaPagedPoolUsage),
10818	kwFmtU64(sz4, MemInfo.QuotaPeakPagedPoolUsage));
10819
10820	if (!GetProcessIoCounters(GetCurrentProcess(), &IoCounters))
10821	memset(&IoCounters, 0, sizeof(IoCounters));
10822	off += sprintf(&szBuf[off], "%s %14s bytes in %s reads [src: OS]\n", szPrf,
10823	kwFmtU64(sz1, IoCounters.ReadTransferCount),
10824	kwFmtU64(sz2, IoCounters.ReadOperationCount));
10825	off += sprintf(&szBuf[off], "%s %14s bytes in %s writes [src: OS]\n", szPrf,
10826	kwFmtU64(sz1, IoCounters.WriteTransferCount),
10827	kwFmtU64(sz2, IoCounters.WriteOperationCount));
10828	off += sprintf(&szBuf[off], "%s %14s bytes in %s other I/O operations [src: OS]\n", szPrf,
10829	kwFmtU64(sz1, IoCounters.OtherTransferCount),
10830	kwFmtU64(sz2, IoCounters.OtherOperationCount));
10831
10832	MemStatus.dwLength = sizeof(MemStatus);
10833	if (!GlobalMemoryStatusEx(&MemStatus))
10834	memset(&MemStatus, 0, sizeof(MemStatus));
10835	off += sprintf(&szBuf[off], "%s %14s bytes used VA, %#" KX64_PRI " bytes available\n", szPrf,
10836	kwFmtU64(sz1, MemStatus.ullTotalVirtual - MemStatus.ullAvailVirtual),
10837	MemStatus.ullAvailVirtual);
10838	off += sprintf(&szBuf[off], "%s %14u %% system memory load\n", szPrf, MemStatus.dwMemoryLoad);
10839
10840	maybe_con_fwrite(szBuf, off, 1, stdout);
10841	fflush(stdout);
10842	}
10843
10844
10845	/**
10846	* Handles what comes after --test.
10847	*
10848	* @returns Exit code.
10849	* @param argc Number of arguments after --test.
10850	* @param argv Arguments after --test.
10851	*/
10852	static int kwTestRun(int argc, char **argv)
10853	{
10854	int i;
10855	int j;
10856	int rcExit;
10857	int cRepeats;
10858	char szCwd[MAX_PATH];
10859	const char *pszCwd = getcwd(szCwd, sizeof(szCwd));
10860	KU32 cEnvVars;
10861	KBOOL fWatcomBrainDamange = K_FALSE;
10862	KBOOL fNoPchCaching = K_FALSE;
10863
10864	/*
10865	* Parse arguments.
10866	*/
10867	/* Repeat count. */
10868	i = 0;
10869	if (i >= argc)
10870	return kwErrPrintfRc(2, "--test takes an repeat count argument or '--'!\n");
10871	if (strcmp(argv[i], "--") != 0)
10872	{
10873	cRepeats = atoi(argv[i]);
10874	if (cRepeats <= 0)
10875	return kwErrPrintfRc(2, "The repeat count '%s' is zero, negative or invalid!\n", argv[i]);
10876	i++;
10877
10878	/* Optional directory change. */
10879	if ( i < argc
10880	&& ( strcmp(argv[i], "--chdir") == 0
10881	\|\| strcmp(argv[i], "-C") == 0 ) )
10882	{
10883	i++;
10884	if (i >= argc)
10885	return kwErrPrintfRc(2, "--chdir takes an argument!\n");
10886	pszCwd = argv[i++];
10887	}
10888
10889	/* Optional watcom flag directory change. */
10890	if ( i < argc
10891	&& ( strcmp(argv[i], "--wcc-brain-damage") == 0
10892	\|\| strcmp(argv[i], "--watcom-brain-damage") == 0) )
10893	{
10894	fWatcomBrainDamange = K_TRUE;
10895	i++;
10896	}
10897
10898	/* Optional watcom flag directory change. */
10899	if ( i < argc
10900	&& strcmp(argv[i], "--no-pch-caching") == 0)
10901	{
10902	fNoPchCaching = K_TRUE;
10903	i++;
10904	}
10905
10906	/* Trigger breakpoint */
10907	if ( i < argc
10908	&& strcmp(argv[i], "--breakpoint") == 0)
10909	{
10910	__debugbreak();
10911	i++;
10912	}
10913
10914	/* Check for '--'. */
10915	if (i >= argc)
10916	return kwErrPrintfRc(2, "Missing '--'\n");
10917	if (strcmp(argv[i], "--") != 0)
10918	return kwErrPrintfRc(2, "Expected '--' found '%s'\n", argv[i]);
10919	i++;
10920	}
10921	else
10922	{
10923	cRepeats = 1;
10924	i++;
10925	}
10926	if (i >= argc)
10927	return kwErrPrintfRc(2, "Nothing to execute after '--'!\n");
10928
10929	/*
10930	* Do the job.
10931	*/
10932	cEnvVars = 0;
10933	while (environ[cEnvVars] != NULL)
10934	cEnvVars++;
10935
10936	for (j = 0; j < cRepeats; j++)
10937	{
10938	rcExit = kSubmitHandleJobUnpacked(argv[i], pszCwd,
10939	argc - i, &argv[i], fWatcomBrainDamange,
10940	cEnvVars, environ, fNoPchCaching,
10941	0, NULL);
10942	KW_LOG(("rcExit=%d\n", rcExit));
10943	kwSandboxCleanupLate(&g_Sandbox);
10944	}
10945
10946	if (getenv("KWORKER_STATS") != NULL)
10947	kwPrintStats();
10948
10949	# ifdef WITH_LOG_FILE
10950	if (g_hLogFile != INVALID_HANDLE_VALUE && g_hLogFile != NULL)
10951	CloseHandle(g_hLogFile);
10952	# endif
10953	return rcExit;
10954	}
10955
10956
10957	int main(int argc, char **argv)
10958	{
10959	KSIZE cbMsgBuf = 0;
10960	KU8 *pbMsgBuf = NULL;
10961	int i;
10962	HANDLE hPipe = INVALID_HANDLE_VALUE;
10963	const char *pszTmp;
10964	KFSLOOKUPERROR enmIgnored;
10965	#if defined(KBUILD_OS_WINDOWS) && defined(KBUILD_ARCH_X86)
10966	PVOID pvVecXcptHandler = AddVectoredExceptionHandler(0 /called last/,
10967	kwSandboxVecXcptEmulateChained);
10968	#endif
10969	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
10970	HANDLE hCurProc = GetCurrentProcess();
10971	PPEB pPeb = kwSandboxGetProcessEnvironmentBlock();
10972	PMY_RTL_USER_PROCESS_PARAMETERS pProcessParams = (PMY_RTL_USER_PROCESS_PARAMETERS)pPeb->ProcessParameters;
10973	DWORD dwType;
10974	#endif
10975
10976
10977	#ifdef WITH_FIXED_VIRTUAL_ALLOCS
10978	/*
10979	* Reserve memory for cl.exe
10980	*/
10981	for (i = 0; i < K_ELEMENTS(g_aFixedVirtualAllocs); i++)
10982	{
10983	g_aFixedVirtualAllocs[i].fInUse = K_FALSE;
10984	g_aFixedVirtualAllocs[i].pvReserved = VirtualAlloc((void *)g_aFixedVirtualAllocs[i].uFixed,
10985	g_aFixedVirtualAllocs[i].cbFixed,
10986	MEM_RESERVE, PAGE_READWRITE);
10987	if ( !g_aFixedVirtualAllocs[i].pvReserved
10988	\|\| g_aFixedVirtualAllocs[i].pvReserved != (void *)g_aFixedVirtualAllocs[i].uFixed)
10989	{
10990	kwErrPrintf("Failed to reserve %p LB %#x: %u\n", g_aFixedVirtualAllocs[i].uFixed, g_aFixedVirtualAllocs[i].cbFixed,
10991	GetLastError());
10992	if (g_aFixedVirtualAllocs[i].pvReserved)
10993	{
10994	VirtualFree(g_aFixedVirtualAllocs[i].pvReserved, g_aFixedVirtualAllocs[i].cbFixed, MEM_RELEASE);
10995	g_aFixedVirtualAllocs[i].pvReserved = NULL;
10996	}
10997	}
10998	}
10999	#endif
11000
11001	/*
11002	* Register our Control-C and Control-Break handlers.
11003	*/
11004	if (!SetConsoleCtrlHandler(kwSandboxCtrlHandler, TRUE /fAdd/))
11005	return kwErrPrintfRc(3, "SetConsoleCtrlHandler failed: %u\n", GetLastError());
11006
11007	/*
11008	* Create the cache and mark the temporary directory as using the custom revision.
11009	*/
11010	g_pFsCache = kFsCacheCreate(KFSCACHE_F_MISSING_OBJECTS \| KFSCACHE_F_MISSING_PATHS);
11011	if (!g_pFsCache)
11012	return kwErrPrintfRc(3, "kFsCacheCreate failed!\n");
11013
11014	pszTmp = getenv("TEMP");
11015	if (pszTmp && *pszTmp != '\0')
11016	kFsCacheSetupCustomRevisionForTree(g_pFsCache, kFsCacheLookupA(g_pFsCache, pszTmp, &enmIgnored));
11017	pszTmp = getenv("TMP");
11018	if (pszTmp && *pszTmp != '\0')
11019	kFsCacheSetupCustomRevisionForTree(g_pFsCache, kFsCacheLookupA(g_pFsCache, pszTmp, &enmIgnored));
11020	pszTmp = getenv("TMPDIR");
11021	if (pszTmp && *pszTmp != '\0')
11022	kFsCacheSetupCustomRevisionForTree(g_pFsCache, kFsCacheLookupA(g_pFsCache, pszTmp, &enmIgnored));
11023
11024	/*
11025	* Make g_abDefLdBuf executable.
11026	*/
11027	if (!VirtualProtect(g_abDefLdBuf, sizeof(g_abDefLdBuf), PAGE_EXECUTE_READWRITE, &dwType))
11028	return kwErrPrintfRc(3, "VirtualProtect(%p, %#x, PAGE_EXECUTE_READWRITE,NULL) failed: %u\n",
11029	g_abDefLdBuf, sizeof(g_abDefLdBuf), GetLastError());
11030
11031	#ifdef WITH_CONSOLE_OUTPUT_BUFFERING
11032	/*
11033	* Get and duplicate the console handles.
11034	*/
11035	/* Standard output. */
11036	g_Sandbox.StdOut.hOutput = pProcessParams->StandardOutput;
11037	if (!DuplicateHandle(hCurProc, pProcessParams->StandardOutput, hCurProc, &g_Sandbox.StdOut.hBackup,
11038	GENERIC_WRITE, FALSE /fInherit/, DUPLICATE_SAME_ACCESS))
11039	kHlpAssertFailedStmt(g_Sandbox.StdOut.hBackup = pProcessParams->StandardOutput);
11040	dwType = GetFileType(g_Sandbox.StdOut.hOutput);
11041	g_Sandbox.StdOut.fIsConsole = dwType == FILE_TYPE_CHAR;
11042	g_Sandbox.StdOut.fFileType = (dwType & ~FILE_TYPE_REMOTE) < 0xf
11043	? (KU8)((dwType & ~FILE_TYPE_REMOTE) \| (dwType >> 8)) : KU8_MAX;
11044	g_Sandbox.HandleStdOut.enmType = KWHANDLETYPE_OUTPUT_BUF;
11045	g_Sandbox.HandleStdOut.cRefs = 0x10001;
11046	g_Sandbox.HandleStdOut.dwDesiredAccess = GENERIC_WRITE;
11047	g_Sandbox.HandleStdOut.u.pOutBuf = &g_Sandbox.StdOut;
11048	g_Sandbox.HandleStdOut.hHandle = g_Sandbox.StdOut.hOutput;
11049	if (g_Sandbox.StdOut.hOutput != INVALID_HANDLE_VALUE)
11050	{
11051	if (kwSandboxHandleTableEnter(&g_Sandbox, &g_Sandbox.HandleStdOut, g_Sandbox.StdOut.hOutput))
11052	g_Sandbox.cFixedHandles++;
11053	else
11054	return kwErrPrintfRc(3, "kwSandboxHandleTableEnter failed for StdOut (%p)!\n", g_Sandbox.StdOut.hOutput);
11055	}
11056	KWOUT_LOG(("StdOut: hOutput=%p (%p) fIsConsole=%d dwType=%#x\n",
11057	g_Sandbox.StdOut.hOutput, g_Sandbox.StdOut.hBackup, g_Sandbox.StdOut.fIsConsole, dwType));
11058
11059	/* Standard error. */
11060	g_Sandbox.StdErr.hOutput = pProcessParams->StandardError;
11061	if (!DuplicateHandle(hCurProc, pProcessParams->StandardError, hCurProc, &g_Sandbox.StdErr.hBackup,
11062	GENERIC_WRITE, FALSE /fInherit/, DUPLICATE_SAME_ACCESS))
11063	kHlpAssertFailedStmt(g_Sandbox.StdErr.hBackup = pProcessParams->StandardError);
11064	dwType = GetFileType(g_Sandbox.StdErr.hOutput);
11065	g_Sandbox.StdErr.fIsConsole = dwType == FILE_TYPE_CHAR;
11066	g_Sandbox.StdErr.fFileType = (dwType & ~FILE_TYPE_REMOTE) < 0xf
11067	? (KU8)((dwType & ~FILE_TYPE_REMOTE) \| (dwType >> 8)) : KU8_MAX;
11068	g_Sandbox.HandleStdErr.enmType = KWHANDLETYPE_OUTPUT_BUF;
11069	g_Sandbox.HandleStdErr.cRefs = 0x10001;
11070	g_Sandbox.HandleStdErr.dwDesiredAccess = GENERIC_WRITE;
11071	g_Sandbox.HandleStdErr.u.pOutBuf = &g_Sandbox.StdErr;
11072	g_Sandbox.HandleStdErr.hHandle = g_Sandbox.StdErr.hOutput;
11073	if ( g_Sandbox.StdErr.hOutput != INVALID_HANDLE_VALUE
11074	&& g_Sandbox.StdErr.hOutput != g_Sandbox.StdOut.hOutput)
11075	{
11076	if (kwSandboxHandleTableEnter(&g_Sandbox, &g_Sandbox.HandleStdErr, g_Sandbox.StdErr.hOutput))
11077	g_Sandbox.cFixedHandles++;
11078	else
11079	return kwErrPrintfRc(3, "kwSandboxHandleTableEnter failed for StdErr (%p)!\n", g_Sandbox.StdErr.hOutput);
11080	}
11081	KWOUT_LOG(("StdErr: hOutput=%p (%p) fIsConsole=%d dwType=%#x\n",
11082	g_Sandbox.StdErr.hOutput, g_Sandbox.StdErr.hBackup, g_Sandbox.StdErr.fIsConsole, dwType));
11083
11084	/* Combined console buffer. */
11085	if (g_Sandbox.StdErr.fIsConsole)
11086	{
11087	g_Sandbox.Combined.hOutput = g_Sandbox.StdErr.hBackup;
11088	g_Sandbox.Combined.uCodepage = GetConsoleCP();
11089	}
11090	else if (g_Sandbox.StdOut.fIsConsole)
11091	{
11092	g_Sandbox.Combined.hOutput = g_Sandbox.StdOut.hBackup;
11093	g_Sandbox.Combined.uCodepage = GetConsoleCP();
11094	}
11095	else
11096	{
11097	g_Sandbox.Combined.hOutput = INVALID_HANDLE_VALUE;
11098	g_Sandbox.Combined.uCodepage = CP_ACP;
11099	}
11100	KWOUT_LOG(("Combined: hOutput=%p uCodepage=%d\n", g_Sandbox.Combined.hOutput, g_Sandbox.Combined.uCodepage));
11101	#endif /* WITH_CONSOLE_OUTPUT_BUFFERING */
11102
11103
11104	/*
11105	* Parse arguments.
11106	*/
11107	for (i = 1; i < argc; i++)
11108	{
11109	if (strcmp(argv[i], "--pipe") == 0)
11110	{
11111	i++;
11112	if (i < argc)
11113	{
11114	char *pszEnd = NULL;
11115	unsigned __int64 u64Value = _strtoui64(argv[i], &pszEnd, 16);
11116	if ( *argv[i]
11117	&& pszEnd != NULL
11118	&& *pszEnd == '\0'
11119	&& u64Value != 0
11120	&& u64Value != (uintptr_t)INVALID_HANDLE_VALUE
11121	&& (uintptr_t)u64Value == u64Value)
11122	hPipe = (HANDLE)(uintptr_t)u64Value;
11123	else
11124	return kwErrPrintfRc(2, "Invalid --pipe argument: %s\n", argv[i]);
11125	}
11126	else
11127	return kwErrPrintfRc(2, "--pipe takes an argument!\n");
11128	}
11129	else if (strcmp(argv[i], "--volatile") == 0)
11130	{
11131	i++;
11132	if (i < argc)
11133	kFsCacheSetupCustomRevisionForTree(g_pFsCache, kFsCacheLookupA(g_pFsCache, argv[i], &enmIgnored));
11134	else
11135	return kwErrPrintfRc(2, "--volatile takes an argument!\n");
11136	}
11137	else if (strcmp(argv[i], "--test") == 0)
11138	return kwTestRun(argc - i - 1, &argv[i + 1]);
11139	else if (strcmp(argv[i], "--priority") == 0)
11140	{
11141	i++;
11142	if (i < argc)
11143	{
11144	char *pszEnd = NULL;
11145	unsigned long uValue = strtoul(argv[i], &pszEnd, 16);
11146	if ( *argv[i]
11147	&& pszEnd != NULL
11148	&& *pszEnd == '\0'
11149	&& uValue >= 1
11150	&& uValue <= 5)
11151	{
11152	DWORD dwClass, dwPriority;
11153	switch (uValue)
11154	{
11155	case 1: dwClass = IDLE_PRIORITY_CLASS; dwPriority = THREAD_PRIORITY_IDLE; break;
11156	case 2: dwClass = BELOW_NORMAL_PRIORITY_CLASS; dwPriority = THREAD_PRIORITY_BELOW_NORMAL; break;
11157	case 3: dwClass = NORMAL_PRIORITY_CLASS; dwPriority = THREAD_PRIORITY_NORMAL; break;
11158	case 4: dwClass = HIGH_PRIORITY_CLASS; dwPriority = 0xffffffff; break;
11159	case 5: dwClass = REALTIME_PRIORITY_CLASS; dwPriority = 0xffffffff; break;
11160	}
11161	SetPriorityClass(GetCurrentProcess(), dwClass);
11162	if (dwPriority != 0xffffffff)
11163	SetThreadPriority(GetCurrentThread(), dwPriority);
11164	}
11165	else
11166	return kwErrPrintfRc(2, "Invalid --priority argument: %s\n", argv[i]);
11167	}
11168	else
11169	return kwErrPrintfRc(2, "--priority takes an argument!\n");
11170
11171	}
11172	else if ( strcmp(argv[i], "--help") == 0
11173	\|\| strcmp(argv[i], "-h") == 0
11174	\|\| strcmp(argv[i], "-?") == 0)
11175	{
11176	printf("usage: kWorker [--volatile dir] [--priority <1-5>] --pipe <pipe-handle>\n"
11177	"usage: kWorker <--help\|-h>\n"
11178	"usage: kWorker <--version\|-V>\n"
11179	"usage: kWorker [--volatile dir] --test [<times> [--chdir <dir>] [--breakpoint] -- args\n"
11180	"\n"
11181	"This is an internal kmk program that is used via the builtin_kSubmit.\n");
11182	return 0;
11183	}
11184	else if ( strcmp(argv[i], "--version") == 0
11185	\|\| strcmp(argv[i], "-V") == 0)
11186	return kbuild_version(argv[0]);
11187	else
11188	return kwErrPrintfRc(2, "Unknown argument '%s'\n", argv[i]);
11189	}
11190
11191	if (hPipe == INVALID_HANDLE_VALUE)
11192	return kwErrPrintfRc(2, "Missing --pipe <pipe-handle> argument!\n");
11193
11194	/*
11195	* Serve the pipe.
11196	*/
11197	for (;;)
11198	{
11199	KU32 cbMsg = 0;
11200	int rc = kSubmitReadIt(hPipe, &cbMsg, sizeof(cbMsg), K_TRUE /fShutdownOkay/);
11201	if (rc == 0)
11202	{
11203	/* Make sure the message length is within sane bounds. */
11204	if ( cbMsg > 4
11205	&& cbMsg <= 25610241024)
11206	{
11207	/* Reallocate the message buffer if necessary. We add 4 zero bytes. */
11208	if (cbMsg + 4 <= cbMsgBuf)
11209	{ /* likely */ }
11210	else
11211	{
11212	cbMsgBuf = K_ALIGN_Z(cbMsg + 4, 2048);
11213	pbMsgBuf = kHlpRealloc(pbMsgBuf, cbMsgBuf);
11214	if (!pbMsgBuf)
11215	return kwErrPrintfRc(1, "Failed to allocate %u bytes for a message buffer!\n", cbMsgBuf);
11216	}
11217
11218	/* Read the whole message into the buffer, making sure there is are a 4 zero bytes following it. */
11219	(KU32 )pbMsgBuf = cbMsg;
11220	rc = kSubmitReadIt(hPipe, &pbMsgBuf[sizeof(cbMsg)], cbMsg - sizeof(cbMsg), K_FALSE /fShutdownOkay/);
11221	if (rc == 0)
11222	{
11223	const char *psz;
11224
11225	pbMsgBuf[cbMsg] = '\0';
11226	pbMsgBuf[cbMsg + 1] = '\0';
11227	pbMsgBuf[cbMsg + 2] = '\0';
11228	pbMsgBuf[cbMsg + 3] = '\0';
11229
11230	/* The first string after the header is the command. */
11231	psz = (const char *)&pbMsgBuf[sizeof(cbMsg)];
11232	if (strcmp(psz, "JOB") == 0)
11233	{
11234	struct
11235	{
11236	KI32 rcExitCode;
11237	KU8 bExiting;
11238	KU8 abZero[3];
11239	} Reply;
11240	Reply.rcExitCode = kSubmitHandleJob(psz, cbMsg - sizeof(cbMsg));
11241	Reply.bExiting = g_fRestart;
11242	Reply.abZero[0] = 0;
11243	Reply.abZero[1] = 0;
11244	Reply.abZero[2] = 0;
11245	rc = kSubmitWriteIt(hPipe, &Reply, sizeof(Reply));
11246	if ( rc == 0
11247	&& !g_fRestart)
11248	{
11249	kwSandboxCleanupLate(&g_Sandbox);
11250	continue;
11251	}
11252	}
11253	else
11254	rc = kwErrPrintfRc(-1, "Unknown command: '%s'\n", psz);
11255	}
11256	}
11257	else
11258	rc = kwErrPrintfRc(-1, "Bogus message length: %u (%#x)\n", cbMsg, cbMsg);
11259	}
11260
11261	/*
11262	* If we're exitting because we're restarting, we need to delay till
11263	* kmk/kSubmit has read the result. Windows documentation says it
11264	* immediately discards pipe buffers once the pipe is broken by the
11265	* server (us). So, We flush the buffer and queues a 1 byte read
11266	* waiting for kSubmit to close the pipe when it receives the
11267	* bExiting = K_TRUE result.
11268	*/
11269	if (g_fRestart)
11270	{
11271	KU8 b;
11272	FlushFileBuffers(hPipe);
11273	ReadFile(hPipe, &b, 1, &cbMsg, NULL);
11274	}
11275
11276	CloseHandle(hPipe);
11277	#ifdef WITH_LOG_FILE
11278	if (g_hLogFile != INVALID_HANDLE_VALUE && g_hLogFile != NULL)
11279	CloseHandle(g_hLogFile);
11280	#endif
11281	if (getenv("KWORKER_STATS") != NULL)
11282	kwPrintStats();
11283	return rc > 0 ? 0 : 1;
11284	}
11285	}
11286
11287
11288	/** @page pg_kWorker kSubmit / kWorker
11289	*
11290	* @section sec_kWorker_Motivation Motivation / Inspiration
11291	*
11292	* The kSubmit / kWorker combo was conceived as a way to speed up VirtualBox
11293	* builds on machines "infested" by Anti Virus protection and disk encryption
11294	* software. Build times jumping from 35-40 min to 77-82 min after the machine
11295	* got "infected".
11296	*
11297	* Speeing up builting of Boot Sector Kit \#3 was also hightly desirable. It is
11298	* mainly a bunch of tiny assembly and C files being compiler a million times.
11299	* As some of us OS/2 users maybe recalls, the Watcom make program can run its
11300	* own toolchain from within the same process, saving a lot of process creation
11301	* and teardown overhead.
11302	*
11303	*
11304	* @section sec_kWorker_kSubmit About kSubmit
11305	*
11306	* When wanting to execute a job in a kWorker instance, it must be submitted
11307	* using the kmk_builtin_kSubmit command in kmk. As the name suggest, this is
11308	* built into kmk and does not exist as an external program. The reason for
11309	* this is that it keep track of the kWorker instances.
11310	*
11311	* The kSubmit command has the --32-bit and --64-bit options for selecting
11312	* between 32-bit and 64-bit worker instance. We generally assume the user of
11313	* the command knows which bit count the executable has, so kSubmit is spared
11314	* the extra work of finding out.
11315	*
11316	* The kSubmit command shares a environment and current directory manipulation
11317	* with the kRedirect command, but not the file redirection. So long no file
11318	* operation is involed, kSubmit is a drop in kRedirect replacement. This is
11319	* hand for tools like OpenWatcom, NASM and YASM which all require environment
11320	* and/or current directory changes to work.
11321	*
11322	* Unlike the kRedirect command, the kSubmit command can also specify an
11323	* internall post command to be executed after the main command succeeds.
11324	* Currently only kmk_builtin_kDepObj is supported. kDepObj gathers dependency
11325	* information from Microsoft COFF object files and Watcom OMF object files and
11326	* is scheduled to replace kDepIDB.
11327	*
11328	*
11329	* @section sec_kWorker_Interaction kSubmit / kWorker interaction
11330	*
11331	* The kmk_builtin_kSubmit communicates with the kWorker instances over pipes.
11332	* A job request is written by kSubmit and kWorker read, unpacks it and executes
11333	* it. When the job is completed, kWorker writes a short reply with the exit
11334	* code and an internal status indicating whether it is going to restart.
11335	*
11336	* The kWorker intance will reply to kSubmit before completing all the internal
11337	* cleanup work, so as not to delay the next job execution unnecessarily. This
11338	* includes checking its own memory consumption and checking whether it needs
11339	* restarting. So, a decision to restart unfortunately have to wait till after
11340	* the next job has completed. This is a little bit unfortunate if the next job
11341	* requires a lot of memory and kWorker has already leaked/used a lot.
11342	*
11343	*
11344	* @section sec_kWorker_How_Works How kWorker Works
11345	*
11346	* kWorker will load the executable specified by kSubmit into memory and call
11347	* it's entrypoint in a lightly sandbox'ed environment.
11348	*
11349	*
11350	* @subsection ssec_kWorker_Loaing Image loading
11351	*
11352	* kWorker will manually load all the executable images into memory, fix them
11353	* up, and make a copy of the virgin image so it can be restored using memcpy
11354	* the next time it is used.
11355	*
11356	* Imported functions are monitored and replacements used for a few of them.
11357	* These replacements are serve the following purposes:
11358	* - Provide a different command line.
11359	* - Provide a different environment.
11360	* - Intercept process termination.
11361	* - Intercept thread creation (only linker is allowed to create threads).
11362	* - Intercept file reading for caching (header files, ++) as file system
11363	* access is made even slower by anti-virus software.
11364	* - Intercept crypto hash APIs to cache MD5 digests of header files
11365	* (c1.dll / c1xx.dll spends a noticable bit of time doing MD5).
11366	* - Intercept temporary files (%TEMP%/_CL_XXXXXXyy) to keep the entirely
11367	* in memory as writing files grows expensive with encryption and
11368	* anti-virus software active.
11369	* - Intercept some file system queries to use the kFsCache instead of
11370	* going to the kernel and slowly worm thru the AV filter driver.
11371	* - Intercept standard output/error and console writes to aggressivly
11372	* buffer the output. The MS CRT does not buffer either when it goes to
11373	* the console, resulting in terrible performance and mixing up output
11374	* with other compile jobs.
11375	* This also allows us to filter out the annoying source file announcements
11376	* by cl.exe.
11377	* - Intercept VirtualAlloc and VirtualFree to prevent
11378	* CL.EXE/C1.DLL/C1XX.DLL from leaking some 72MB internal allocat area.
11379	* - Intercept FlsAlloc/FlsFree to make sure the allocations are freed and
11380	* the callbacks run after each job.
11381	* - Intercept HeapCreate/HeapFree to reduce leaks from statically linked
11382	* executables and tools using custom heaps (like the microsoft linker).
11383	* [exectuable images only]
11384	* - Intercept atexit and _onexit registration to be able run them after
11385	* each job instead of crashing as kWorker exits. This also helps avoid
11386	* some leaks. [executable image only]
11387	*
11388	* DLLs falls into two categories, system DLLs which we always load using the
11389	* native loader, and tool DLLs which can be handled like the executable or
11390	* optionally using the native loader. We maintain a hardcoded white listing of
11391	* tool DLLs we trust to load using the native loader.
11392	*
11393	* Imports of natively loaded DLLs are processed too, but we only replace a
11394	* subset of the functions compared to natively loaded excutable and DLL images.
11395	*
11396	* DLLs are never unloaded and we cache LoadLibrary requests (hash the input).
11397	* This is to speed up job execution.
11398	*
11399	* It was thought that we needed to restore (memcpy) natively loaded tool DLLs
11400	* for each job run, but so far this hasn't been necessary.
11401	*
11402	*
11403	* @subsection ssec_kWorker_Optimizing Optimizing the Compiler
11404	*
11405	* The Visual Studio 2010 C/C++ compiler does a poor job at processing header
11406	* files and uses a whole bunch of temporary files (in %TEMP%) for passing
11407	* intermediate representation between the first (c1/c1xx.dll) and second pass
11408	* (c2.dll).
11409	*
11410	* kWorker helps the compiler as best as it can. Given a little knowledge about
11411	* stable and volatile file system areas, it can do a lot of caching that a
11412	* normal compiler driver cannot easily do when given a single file.
11413	*
11414	*
11415	* @subsubsection sssec_kWorker_Headers Cache Headers Files and Searches
11416	*
11417	* The preprocessor part will open and process header files exactly as they are
11418	* encountered in the source files. If string.h is included by the main source
11419	* and five other header files, it will be searched for (include path), opened,
11420	* read, MD5-summed, and pre-processed six times. The last five times is just a
11421	* waste of time because of the guards or \#pragma once. A smart compiler would
11422	* make a little extra effort and realize this.
11423	*
11424	* kWorker will cache help the preprocessor by remembering places where the
11425	* header was not found with help of kFsCache, and cache the file in memory when
11426	* found. The first part is taken care of by intercepting GetFileAttributesW,
11427	* and the latter by intercepting CreateFileW, ReadFile and CloseFile. Once
11428	* cached, the file is kept open and the CreateFileW call returns a duplicate of
11429	* that handle. An internal handle table is used by ReadFile and CloseFile to
11430	* keep track of intercepted handles (also used for temporary file, temporary
11431	* file mappings, console buffering, and standard out/err buffering).
11432	*
11433	* PS. The header search optimization also comes in handy when cl.exe goes on
11434	* thru the whole PATH looking for c1/c1xx.exe and c2.exe after finding
11435	* c1/c1xx.dll and c2.dll. My guess is that the compiler team can
11436	* optionally compile the three pass DLLs as executables during development
11437	* and problem analysis.
11438	*
11439	*
11440	* @subsubsection sssec_kWorker_Temp_Files Temporary Files In Memory
11441	*
11442	* The issues of the temporary files is pretty severe on the Dell machine used
11443	* for benchmarking with full AV and encryption. The synthetic benchmark
11444	* improved by 30% when kWorker implemented measures to keep them entirely in
11445	* memory.
11446	*
11447	* kWorker implement these by recognizing the filename pattern in CreateFileW
11448	* and creating/opening the given file as needed. The handle returned is a
11449	* duplicate of the current process, thus giving us a good chance of catching
11450	* API calls we're not intercepting.
11451	*
11452	* In addition to CreateFileW, we also need to intercept GetFileType, ReadFile,
11453	* WriteFile, SetFilePointer+Ex, SetEndOfFile, and CloseFile. The 2nd pass
11454	* additionally requires GetFileSize+Ex, CreateFileMappingW, MapViewOfFile and
11455	* UnmapViewOfFile.
11456	*
11457	*
11458	* @section sec_kWorker_Numbers Some measurements.
11459	*
11460	* - r2881 building src/VBox/Runtime:
11461	* - without: 2m01.016388s = 120.016388 s
11462	* - with: 1m15.165069s = 75.165069 s => 120.016388s - 75.165069s = 44.851319s => 44.85/120.02 = 37% speed up.
11463	* - r2884 building vbox/debug (r110512):
11464	* - without: 11m14.446609s = 674.446609 s
11465	* - with: 9m01.017344s = 541.017344 s => 674.446609s - 541.017344s = 133.429265 => 133.43/674.45 = 19% speed up
11466	* - r2896 building vbox/debug (r110577):
11467	* - with: 8m31.182384s = 511.182384 s => 674.446609s - 511.182384s = 163.264225 = 163.26/674.45 = 24% speed up
11468	* - r2920 building vbox/debug (r110702) on Skylake (W10/amd64, only standard
11469	* MS Defender as AV):
11470	* - without: 10m24.990389s = 624.990389s
11471	* - with: 08m04.738184s = 484.738184s
11472	* - delta: 624.99s - 484.74s = 140.25s
11473	* - saved: 140.25/624.99 = 22% faster
11474	*
11475	*
11476	* @subsection subsec_kWorker_Early_Numbers Early Experiments
11477	*
11478	* These are some early experiments doing 1024 compilations of
11479	* VBoxBS2Linker.cpp using a hard coded command line and looping in kWorker's
11480	* main function:
11481	*
11482	* Skylake (W10/amd64, only stdandard MS defender):
11483	* - cmd 1: 48 /1024 = 0x0 (0.046875) [for /l %i in (1,1,1024) do ...]
11484	* - kmk 1: 44 /1024 = 0x0 (0.04296875) [all: ; 1024 x cl.exe]
11485	* - run 1: 37 /1024 = 0x0 (0.0361328125) [just process creation gain]
11486	* - run 2: 34 /1024 = 0x0 (0.033203125) [get file attribs]
11487	* - run 3: 32.77 /1024 = 0x0 (0.032001953125) [read caching of headers]
11488	* - run 4: 32.67 /1024 = 0x0 (0.031904296875) [loader tweaking]
11489	* - run 5: 29.144/1024 = 0x0 (0.0284609375) [with temp files in memory]
11490	*
11491	* Dell (W7/amd64, infected by mcafee):
11492	* - kmk 1: 285.278/1024 = 0x0 (0.278591796875)
11493	* - run 1: 134.503/1024 = 0x0 (0.1313505859375) [w/o temp files in memory]
11494	* - run 2: 78.161/1024 = 0x0 (0.0763291015625) [with temp files in memory]
11495	*
11496	* The command line:
11497	* @code{.cpp}
11498	"\"E:/vbox/svn/trunk/tools/win.x86/vcc/v10sp1/bin/amd64/cl.exe\" -c -c -TP -nologo -Zi -Zi -Zl -GR- -EHsc -GF -Zc:wchar_t- -Oy- -MT -W4 -Wall -wd4065 -wd4996 -wd4127 -wd4706 -wd4201 -wd4214 -wd4510 -wd4512 -wd4610 -wd4514 -wd4820 -wd4365 -wd4987 -wd4710 -wd4061 -wd4986 -wd4191 -wd4574 -wd4917 -wd4711 -wd4611 -wd4571 -wd4324 -wd4505 -wd4263 -wd4264 -wd4738 -wd4242 -wd4244 -WX -RTCsu -IE:/vbox/svn/trunk/tools/win.x86/vcc/v10sp1/include -IE:/vbox/svn/trunk/tools/win.x86/vcc/v10sp1/atlmfc/include -IE:/vbox/svn/trunk/tools/win.x86/sdk/v7.1/Include -IE:/vbox/svn/trunk/include -IE:/vbox/svn/trunk/out/win.amd64/debug -IE:/vbox/svn/trunk/tools/win.x86/vcc/v10sp1/include -IE:/vbox/svn/trunk/tools/win.x86/vcc/v10sp1/atlmfc/include -DVBOX -DVBOX_WITH_64_BITS_GUESTS -DVBOX_WITH_REM -DVBOX_WITH_RAW_MODE -DDEBUG -DDEBUG_bird -DDEBUG_USERNAME=bird -DRT_OS_WINDOWS -D__WIN__ -DRT_ARCH_AMD64 -D__AMD64__ -D__WIN64__ -DVBOX_WITH_DEBUGGER -DRT_LOCK_STRICT -DRT_LOCK_STRICT_ORDER -DIN_RING3 -DLOG_DISABLED -DIN_BLD_PROG -D_CRT_SECURE_NO_DEPRECATE -FdE:/vbox/svn/trunk/out/win.amd64/debug/obj/VBoxBs2Linker/VBoxBs2Linker-obj.pdb -FD -FoE:/vbox/svn/trunk/out/win.amd64/debug/obj/VBoxBs2Linker/VBoxBs2Linker.obj E:\\vbox\\svn\\trunk\\src\\VBox\\ValidationKit\\bootsectors\\VBoxBs2Linker.cpp"
11499	* @endcode
11500	*/
11501

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

source: kBuild/trunk/src/kWorker/kWorker.c@ 3192

Download in other formats: