kWorker.c@ 2957

Last change on this file since 2957 was 2957, checked in by bird, 9 years ago
kWorker: precompiled header files didn't work out, unfortunately.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 373.0 KB

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

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

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

Download in other formats: