kWorker.c@ 2941

Last change on this file since 2941 was 2941, checked in by bird, 9 years ago
kWorker: More moc work - mainly related to mapping read cached files.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 361.7 KB

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

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

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

Download in other formats: