原帖来源：【Win32API】关于CreateProcess的第二个参数的研究 https://www.0xaa55.com/thread-27526-1-1.html (出处: 技术宅的结界)

　　在学Win32API编程的过程中肯定少不了创建子进程的需求，以前在学VB6的时候就会用到Shell函数来创建子进程，到了学VC的时候就需要手动调用WinAPI来实现了，这个时候我们最开始发现和VB6的Shell类似的自然是WinExec函数（连参数都跟VB6的Shell“一样”）。随着需求的进一步增加又会发现WinExec的功能不够用了（比如VB6的Shell至少会返回进程id，而WinExec返回的却是错误代码，还有就是WinExec只有ANSI版没有Unicode版），这时就会接触到一个更加高级的API函数CreateProcess，可以发现WinExec的第一个参数对应CreateProcess的第二个参数，WinExec的第二参数则是对应STARTUPINFO结构体中的wShowWindow字段。最开始大家都是先从ANSI编程开始的按照WinExec的习惯去使用CreateProcessA没有任何问题，后来开始学习Unicode编程了用到CreateProcessW就发现不对劲了（程序产生了0xC0000005异常），新手时期大多数人都会一脸懵逼。

　　在后面有了一定技术水平之后，就会知道0xC0000005异常是内存权限错误，而CreateProcessW的第二个参数的类型是LPWSTR（并且标记了__inout_opt），也就是说这个参数是会被CreateProcessW修改的，于是试了一下先把字符串常量赋值给字符数组变量再传给CreateProcessW果然就OJBK了（提示：在旧版C艹标准中，const wchar_t *和const wchar_t []的都是不能赋值给wchar_t *变量的，但是 L"字符串常量" 却可以赋值给wchar_t *这就是导致CreateProcessW坑到一大堆新手的罪魁祸首）。当第一次了解到这里的时候直接就被震惊了，甚至感觉很不科学，明明在CreateProcessW返回后的这个参数的内容和传入之前一模一样，为啥就被修改了呢？既然修改了返回后的内容还是一样，那修改这个参数的意义是啥呢？同样是 __inout_opt LPSTR 参数的CreateProcessA为啥却没有这个问题？随着一系列的疑问下来，便决定对CreateProcess的这第二个参数好好研究。

　　根据MSDN的描述来看，当第一个参数lpApplicationName为nullptr时，会根据第二个参数lpCommandLine中的第一个命令行来生成lpApplicationName，看到这里还暂时看不出来为啥跟lpCommandLine参数被修改有啥关系，接下来再看如果lpCommandLine参数的第一个命令行不是绝对路径的话，它会按搜素路径顺序去查找对应可执行文件（1.当前进程的主exe安装路径，2.当前进程的工作目录，3.GetSystemDirectory返回的目录，4. GetWindowsDirectory返回的目录，5.Path环境变量对应的目录），到这里绝对大部对C/C艹语言或WinAPI不熟悉的开发者多半会觉得不就是查找文件嘛，跟lpCommandLine被修改有啥关系？这时我就需要提示一下，在C语言标准中字符串都是以\0为结束标记的，而lpCommandLine是包含多个命令行参数组合的字符串，每个命令行参数之间都是使用空格来分割的（如果参数中本身包含空格则需要带上双引号，如果参数本身也包含双引号那就需要连续两个双引号转义一个双引号），这时是不是就会想到lpCommandLine中的第一个命令行参数大概率不会是\0结尾（除非只有一个参数且没带双引号的情况）。所以，CreateProcessW是不是需要先把可执行文件名结尾处的空格或双引号先临时改成\0才能实现对文件的搜索？至于最后调用完后返回的内容没有变，这是因为在搜索完可执行文件的全路径后，再最终创建进程的时候要把原始的命令行参数传给子进程，所以必须得改回去。经过测试发现，当我们正确传入非空lpApplicationName参数时，再给lpCommandLine直接传字符串常量，这时调用CreateProcessW就没有任何问题，这也更加进一步验证了lpCommandLine被修改问题的关键就在这个路径搜索上。

　　关于CreateProcessW的原理是研究明白了，但大家是不是还有很多疑惑？为啥CreateProcessA的lpApplicationName为nullptr给lpCommandLine传常量却没有这个问题呢？难道CreateProcessA不走路径搜索吗？答案显然不是，因为在Win32中kernel32.dll这层API函数的ANSI版绝大多数都是内部做临时编码转换，然后再调用的Unicode版实现。也就是说CreateProcessA会把ANSI字符集的lpCommandLine在内存中临时转换成Unicode字符集的副本，然后再调用CreateProcessW，这样CreateProcessW在处理路径搜索时修改的就是在CreateProcessA分配的临时内存上（这个内存是一定具有写入权限的，不然转换出来的Unicode字符串也没法写进去），而不是CreateProcessA本来接收的lpCommandLine参数。因此CreateProcessA永远不会修改用户传入的参数，自然也就不会有这个问题。在最新版的MSDN文档中巨硬已经补充了一句“此函数的 Unicode 版本（CreateProcessW）可以修改此字符串的内容。 因此，此参数不能是指向只读内存的指针（例如 常量 变量或文本字符串）。 如果此参数是常量字符串，则函数可能会导致访问冲突。”

　　自此，我们现在已经完全搞明白了CreateProcess的第二个参数lpCommandLine神奇现象的原理，下面就来模仿一下其内部实现（这里会用到一个冷门API函数SearchPathW）：

1. 
   
2. #define WIN32_LEAN_AND_MEAN
   
3. #include <Windows.h>
   
4. #include <malloc.h>
   
5. 
   
6. #ifdef UNICODE
   
7. #define MyCreateProcess  MyCreateProcessW
   
8. #else
   
9. #define MyCreateProcess  MyCreateProcessA
   
10. #endif // !UNICODE
    
11. 
    
12. // Unicode 版实现
    
13. EXTERN_C DECLSPEC_NOINLINE BOOL WINAPI MyCreateProcessW(__in_opt LPCWSTR lpApplicationName, __inout_opt LPWSTR lpCommandLine, __in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes, __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in BOOL bInheritHandles, __in DWORD dwCreationFlags, __in_opt LPVOID lpEnvironment, __in_opt LPCWSTR lpCurrentDirectory, __in LPSTARTUPINFOW lpStartupInfo, __out LPPROCESS_INFORMATION lpProcessInformation)
    
14. {
    
15.         // 先判断第一个参数为空且第二个参数不为空的情况（如果成立则从lpCommandLine中取第一个命令行参数来搜索可执行文件）
    
16.         if (!lpApplicationName && lpCommandLine) {
    
17.                 // 定义两个变量分别标记lpCommandLine中可执行文件的起始位置和结束位置
    
18.                 LPWSTR app4cl = lpCommandLine, appec;
    
19.                 // 如果lpCommandLine的第一个字符不是双引号，那么就以空格结尾，否则就以双引号结尾。
    
20.                 if (L'"' != *app4cl) appec = wcschr(app4cl, L' ');
    
21.                 else appec = wcschr(++app4cl, L'"');
    
22.                 // 如果找到正确位置需要临时修改成\0结束标记，否则SearchPathW会出错，没有找到则说明lpCommandLine中没有多个参数（刚好本身就有\0结尾）。
    
23.                 if (appec) *appec = L'\0';
    
24.                 // 开始用从lpCommandLine中取到的文件名搜索对应的.exe文件（SearchPathW的第一个参数传nullptr表示使用系统默认的搜索路径规则）
    
25.                 DWORD len = SearchPathW(nullptr, app4cl, L".exe", 0, nullptr, nullptr);        // 在不接收搜索结果的情况下函数会返回包括\0的长度
    
26.                 if (len) {        // 搜索成功则分配内存并获取结果
    
27.                         // 一般来说可执行文件路径都会被限制在MAX_PATH长度，不会太长这里就偷懒从堆栈上来分配临时内存了。
    
28.                         (void*&)lpApplicationName = _alloca(len << 1);        // 注意：内存的分配都是按字节大小来算长度的，所以Unicode文本长度需要 * 2。
    
29.                         // 分配好缓冲区内存之后就可以开始接收搜索结果了（提示：现在返回的长度是不包括\0的了）
    
30.                         len = SearchPathW(nullptr, app4cl, L".exe", len, LPWSTR(lpApplicationName), nullptr);
    
31.                 }
    
32.                 // 搜索完成后就把被临时修改的lpCommandLine给改回去（由于确定只会有双引号和空格两种情况，所以我这里偷懒了没有保存原始的字符）
    
33.                 if (appec) *appec = app4cl != lpCommandLine ? L'"' : L' ';
    
34.                 // 如果搜索失败则返回失败（SearchPathW内部会设置LastError，不用自己再设置）
    
35.                 if (!len) return FALSE;
    
36.         }
    
37.         // 假设存在的一个内部CreateProcess函数（由于这里仅研究第二个参数lpCommandLine，不考虑其它细节，因此放弃了使用RtlCreateUserProcess来实现的想法）
    
38.         return CreateProcessW(lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
    
39. }
    
40. 
    
41. // ANSI 版实现
    
42. EXTERN_C DECLSPEC_NOINLINE BOOL WINAPI MyCreateProcessA(__in_opt LPCSTR lpApplicationName, __inout_opt LPSTR lpCommandLine, __in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes, __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in BOOL bInheritHandles, __in DWORD dwCreationFlags, __in_opt LPVOID lpEnvironment, __in_opt LPCSTR lpCurrentDirectory, __in LPSTARTUPINFOA lpStartupInfo, __out LPPROCESS_INFORMATION lpProcessInformation)
    
43. {
    
44.         // 字符串参数的索引常量
    
45.         enum { AppLen, CmdLen, CurLen, DskLen, TitLen, LensCount, };
    
46.         // Unicode 缓冲区
    
47.         LPSTARTUPINFOEXW psiex = nullptr;
    
48.         __try {
    
49.                 int srcls[LensCount], dstls[LensCount + 1];
    
50.                 // 计算所有ANSI参数的完整长度（含\0，因此nullptr长度为0 ""则为1）
    
51.                 srcls[AppLen] = lpApplicationName ? lstrlenA(lpApplicationName) + 1 : 0;
    
52.                 srcls[CmdLen] = lpCommandLine ? lstrlenA(lpCommandLine) + 1 : 0;
    
53.                 srcls[CurLen] = lpCurrentDirectory ? lstrlenA(lpCurrentDirectory) + 1 : 0;
    
54.                 srcls[DskLen] = lpStartupInfo->lpDesktop ? lstrlenA(lpStartupInfo->lpDesktop) + 1 : 0;
    
55.                 srcls[TitLen] = lpStartupInfo->lpTitle ? lstrlenA(lpStartupInfo->lpTitle) + 1 : 0;
    
56.                 *dstls = ((max(sizeof(*lpStartupInfo), lpStartupInfo->cb) + 3) >> 2) << 1;
    
57.                 // 计算所有ANSI参数转换为Unicode之后的完全长度（含\0，算的字符个数不是字节数）
    
58.                 dstls[AppLen + 1] = lpApplicationName ? MultiByteToWideChar(CP_ACP, 0, lpApplicationName, srcls[AppLen], nullptr, 0) : 0;
    
59.                 dstls[CmdLen + 1] = lpCommandLine ? MultiByteToWideChar(CP_ACP, 0, lpCommandLine, srcls[CmdLen], nullptr, 0) : 0;
    
60.                 dstls[CurLen + 1] = lpCurrentDirectory ? MultiByteToWideChar(CP_ACP, 0, lpCurrentDirectory, srcls[CurLen], nullptr, 0) : 0;
    
61.                 dstls[DskLen + 1] = lpStartupInfo->lpDesktop ? MultiByteToWideChar(CP_ACP, 0, lpStartupInfo->lpDesktop, srcls[DskLen], nullptr, 0) : 0;
    
62.                 dstls[TitLen + 1] = lpStartupInfo->lpTitle ? MultiByteToWideChar(CP_ACP, 0, lpStartupInfo->lpTitle, srcls[TitLen], nullptr, 0) : 0;
    
63.                 // 累加所有长度，以便后期使用的复杂度从On降至O1
    
64.                 for (int i = 0; i < LensCount;) { register auto cur = dstls[i]; dstls[++i] += cur; }
    
65.                 // 使用总长度分配缓冲区内存（这次的参数可能会特别长，特别是lpCommandLine最大长度为32767，因此最好从堆上分配）
    
66.                 (LPVOID&)psiex = LocalAlloc(LMEM_FIXED, dstls[LensCount] << 1);
    
67.                 if (!psiex) __leave;
    
68.                 // 拷贝StartupInfo结构体（STARTUPINFOA和STARTUPINFOW的结构体完全一致，只是需要将其中的LPSTR字段替换成LPWSTR字段）
    
69.                 CopyMemory(psiex, lpStartupInfo, max(sizeof(*lpStartupInfo), lpStartupInfo->cb));
    
70.                 // 转换所有的ANSI参数为Unicode，并按条件替换
    
71.                 if (lpApplicationName) MultiByteToWideChar(CP_ACP, 0, lpApplicationName, srcls[AppLen], LPWSTR(psiex) + dstls[AppLen], dstls[AppLen + 1] - dstls[AppLen]);
    
72.                 if (lpCommandLine) MultiByteToWideChar(CP_ACP, 0, lpCommandLine, srcls[CmdLen], LPWSTR(psiex) + dstls[CmdLen], dstls[CmdLen + 1] - dstls[CmdLen]);
    
73.                 if (lpCurrentDirectory) MultiByteToWideChar(CP_ACP, 0, lpCurrentDirectory, srcls[CurLen], LPWSTR(psiex) + dstls[CurLen], dstls[CurLen + 1] - dstls[CurLen]);
    
74.                 if (lpStartupInfo->lpDesktop) MultiByteToWideChar(CP_ACP, 0, lpStartupInfo->lpDesktop, srcls[DskLen], psiex->StartupInfo.lpDesktop = LPWSTR(psiex) + dstls[DskLen], dstls[DskLen + 1] - dstls[DskLen]);
    
75.                 if (lpStartupInfo->lpTitle) MultiByteToWideChar(CP_ACP, 0, lpStartupInfo->lpTitle, srcls[TitLen], psiex->StartupInfo.lpTitle = LPWSTR(psiex) + dstls[TitLen], dstls[TitLen + 1] - dstls[TitLen]);
    
76.                 //转换完成后调用对应的 Unicode 版实现就行了
    
77.                 return MyCreateProcessW((lpApplicationName ? LPCWSTR(psiex) + dstls[AppLen] : 0), (lpCommandLine ? LPWSTR(psiex) + dstls[CmdLen] : 0), lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, (lpCurrentDirectory ? LPCWSTR(psiex) + dstls[CurLen] : 0), &psiex->StartupInfo, lpProcessInformation);
    
78.         }
    
79.         __finally {
    
80.                 // 再离开作用域后需要释放从堆中分配的内存
    
81.                 if (psiex) LocalFree(psiex);
    
82.         }
    
83.         return FALSE;
    
84. }
    
85. 
    
86. // WinExec 实现
    
87. EXTERN_C DECLSPEC_NOINLINE UINT WINAPI MyWinExec(__in LPCSTR lpCmdLine, __in UINT uCmdShow)
    
88. {
    
89.         // 等待超时时长（WinExec最长等待30秒，ShellExecuteEx则是60秒，CreateProcess则不会做任何等待）
    
90.         static const DWORD TIMEOUT = 30000;
    
91.         PROCESS_INFORMATION processInfo;
    
92.         // 启动参数设置（WinExec只有用到wShowWindow字段）
    
93.         STARTUPINFOA startupInfo = { sizeof(startupInfo), nullptr, nullptr, nullptr, 0, 0, 0, 0, 0, 0, 0, STARTF_USESHOWWINDOW, WORD(uCmdShow), };
    
94.         // 调用CreateProcessA（由于CreateProcessA内部永远不会修改到lpCommandLine，所以直接强转LPSTR传递是安全的）
    
95.         if (MyCreateProcessA(nullptr, LPSTR(lpCmdLine), nullptr, nullptr, FALSE, 0, nullptr, nullptr, &startupInfo, &processInfo)) {
    
96.                 // 关闭线程句柄（用不上）
    
97.                 CloseHandle(processInfo.hThread);
    
98.                 // 等待子进程GUI初始化完成（以第一次把消息队列清空为条件）
    
99.                 WaitForInputIdle(processInfo.hProcess, TIMEOUT);
    
100.                 // 关闭进程句柄（用完了）
     
101.                 CloseHandle(processInfo.hProcess);
     
102.                 // 返回成功
     
103.                 return HINSTANCE_ERROR + TRUE;
     
104.         }
     
105.         // 失败则获取错误码
     
106.         DWORD dwErr = GetLastError();
     
107.         // 转换错误码
     
108.         switch (dwErr)
     
109.         {
     
110.         case ERROR_FILE_NOT_FOUND:        // 找不到可执行文件
     
111.         case ERROR_PATH_NOT_FOUND:        // 无效的文件路径
     
112.                 break;
     
113.         case ERROR_BAD_EXE_FORMAT:        // 文件不是EXE格式
     
114.                 dwErr = ERROR_BAD_FORMAT;
     
115.                 break;
     
116.         default:        // 其它错误状态都是返回0
     
117.                 dwErr = FALSE;
     
118.         }
     
119.         return UINT(dwErr);
     
120. }
     

复制代码

压缩包密码没有密码 ，如果有那就在隐藏内容中（回帖可见） ）

游客，如果您要查看本帖隐藏内容请回复

如果有任何关于WIN32API的疑问（包括内核API），都可以直接参考泄露的WINXP源码。

膜拜大佬技术贴
兴奋的进来，一脸懵逼的出去。。。

啥也不说了，帖子就是带劲！

美俪女神 发表于 2024-12-28 07:35
如果有任何关于WIN32API的疑问（包括内核API），都可以直接参考泄露的WINXP源码。 ...

找到XP源码了，它内部确实是使用的临时修改lpCommandLine参数然后SearchPathW搜索的exe文件，搜完后再修改回来，最后再真正创建进程：

1. 
   
2. BOOL
   
3. WINAPI
   
4. CreateProcessInternalW(
   
5.     HANDLE hUserToken,
   
6.     LPCWSTR lpApplicationName,
   
7.     LPWSTR lpCommandLine,
   
8.     LPSECURITY_ATTRIBUTES lpProcessAttributes,
   
9.     LPSECURITY_ATTRIBUTES lpThreadAttributes,
   
10.     BOOL bInheritHandles,
    
11.     DWORD dwCreationFlags,
    
12.     LPVOID lpEnvironment,
    
13.     LPCWSTR lpCurrentDirectory,
    
14.     LPSTARTUPINFOW lpStartupInfo,
    
15.     LPPROCESS_INFORMATION lpProcessInformation,
    
16.     PHANDLE hRestrictedUserToken
    
17.     )
    
18. 
    
19. /*++
    
20. 
    
21. Routine Description:
    
22. 
    
23.     This is the worker routine for CreateProcess and CreateProcessAsUser.
    
24.     CreateProcessAsUser supplies a User token to be stamped on the new process.
    
25.     CreateProcess supplies NULL and the current process token is used.
    
26. 
    
27.     A process and thread object are created and a handle opened to each
    
28.     object using CreateProcessInternal.  Note that WinExec and LoadModule are
    
29.     still supported, but are implemented as a call to CreateProcess.
    
30. 
    
31. Arguments:
    
32. 
    
33.     hUserToken - Supplies an optional token handle to be set on the new process.
    
34.         Process token is used is this parameter is NULL.
    
35. 
    
36.     lpApplicationName - Supplies an optional pointer to a null terminated
    
37.         character string that contains the name of the image file to
    
38.         execute.  This is a fully qualified DOS path name.  If not
    
39.         specified, then the image file name is the first whitespace
    
40.         delimited token on the command line.
    
41. 
    
42.     lpCommandLine - Supplies a null terminated character string that
    
43.         contains the command line for the application to be executed.
    
44.         The entire command line is made available to the new process
    
45.         using GetCommandLine.  If the lpApplicationName parameter was
    
46.         not specified, then the first token of the command line
    
47.         specifies file name of the application (note that this token
    
48.         begins at the beginning of the command line and ends at the
    
49.         first "white space" character).  If the file name does not
    
50.         contain an extension (the presence of a "."), then .EXE is
    
51.         assumed.  If the file name does not contain a directory path,
    
52.         Windows will search for the executable file in:
    
53. 
    
54.           - The current directory
    
55. 
    
56.           - The windows directory
    
57. 
    
58.           - The windows system directory
    
59. 
    
60.           - The directories listed in the path environment variable
    
61. 
    
62.         This parameter is optional onlu if the lpApplicationName
    
63.         parameter is specified.  In this case the command line the
    
64.         application receives will be the application name.
    
65. 
    
66.     lpProcessAttributes - An optional parameter that may be used to
    
67.         specify the attributes of the new process.  If the parameter is
    
68.         not specified, then the process is created without a security
    
69.         descriptor, and the resulting handle is not inherited on process
    
70.         creation:
    
71. 
    
72.         SECURITY_ATTRIBUTES Structure:
    
73. 
    
74.         DWORD nLength - Specifies the length of this structure.  Must be
    
75.             set to sizeof( SECURITY_ATTRUBUTES ).
    
76. 
    
77.         LPVOID lpSecurityDescriptor - Points to a security descriptor for
    
78.             the object (must be NULL for Win32, used on NT/Win32). The
    
79.             security descriptor controls the sharing of an object.
    
80. 
    
81.         BOOL bInheritHandle - Supplies a flag that indicates whether
    
82.             or not the returned handle is to be inherited by a new
    
83.             process during process creation.  A value of TRUE
    
84.             indicates that the new process will inherit the handle.
    
85. 
    
86.     lpThreadAttributes - An optional parameter that may be used to specify
    
87.         the attributes of the new thread.  If the parameter is not
    
88.         specified, then the thread is created without a security
    
89.         descriptor, and the resulting handle is not inherited on
    
90.         process creation.
    
91. 
    
92.     dwCreationFlags - Supplies additional flags that control the creation
    
93.         of the process.
    
94. 
    
95.         dwCreationFlags Flags:
    
96. 
    
97.         DEBUG_PROCESS - If this flag bit is set, then the creating
    
98.             process is treated as a debugger, and the process being
    
99.             created is created as a debugee.  All debug events occuring
    
100.             in the debugee are reported to the debugger.  If this bit is
     
101.             clear, but the calling process is a debugee, then the
     
102.             process becomes a debugee of the calling processes debugger.
     
103.             If this bit is clear and the calling processes is not a
     
104.             debugee then no debug related actions occur.
     
105. 
     
106.         DEBUG_ONLY_THIS_PROCESS - If this flag is set, then the
     
107.             DEBUG_PROCESS flag bit must also be set.  The calling
     
108.             process is is treated as a debugger, and the new process is
     
109.             created as its debuggee.  If the new process creates
     
110.             additional processes, no debug related activities (with
     
111.             respect to the debugger) occur.
     
112. 
     
113.         CREATE_SUSPENDED - The process is created, but the initial thread
     
114.             of the process remains suspended. The creator can resume this
     
115.             thread using ResumeThread. Until this is done, code in the
     
116.             process will not execute.
     
117. 
     
118.         CREATE_UNICODE_ENVIRONMENT - If set, the environment pointer
     
119.             points to a Unicode environment block.  Otherwise, the
     
120.             block is ANSI (actually OEM.)
     
121. 
     
122.     bInheritHandles - Supplies a flag that specifies whether or not the
     
123.         new process is to inherit handles to objects visible to the
     
124.         calling process.  A value of TRUE causes handles to be inherited
     
125.         by the new process.  If TRUE was specified, then for each handle
     
126.         visible to the calling process, if the handle was created with
     
127.         the inherit handle option, the handle is inherited to the new
     
128.         process.  The handle has the same granted access in the new
     
129.         process as it has in the calling process, and the value of the
     
130.         handle is the same.
     
131. 
     
132.     lpEnvironment - An optional parameter, that if specified, supplies a
     
133.         pointer to an environment block.  If the parameter is not
     
134.         specified, the environment block of the current process is used.
     
135.         This environment block is made available to the new process
     
136.         using GetEnvironmentStrings.
     
137. 
     
138.     lpCurrentDirectory - An optional parameter, that if specified,
     
139.         supplies a string representing the current drive and directory
     
140.         for the new process.  The string must be a fully qualified
     
141.         pathname that includes a drive letter.  If the parameter is not
     
142.         specified, then the new process is created with the same current
     
143.         drive and directory as the calling process.  This option is
     
144.         provided primarily for shells that want to start an application
     
145.         and specify its initial drive and working directory.
     
146. 
     
147.     lpStartupInfo - Supplies information that specified how the
     
148.         applications window is to be shown. This structure is described
     
149.         in the Win32 User Interface API Book.
     
150. 
     
151.     lpProcessInformation - Returns identification information about the
     
152.         new process.
     
153. 
     
154.     PROCESS_INFORMATION Structure:
     
155. 
     
156.         HANDLE hProcess - Returns a handle to the newly created process.
     
157.             Through the handle, all operations on process objects are
     
158.             allowed.
     
159. 
     
160.         HANDLE hThread - Returns a handle to the newly created thread.
     
161.             Through the handle, all operations on thread objects are
     
162.             allowed.
     
163. 
     
164.         DWORD dwProcessId - Returns a global process id that may be used
     
165.             to identify a process.  The value is valid from the time the
     
166.             process is created until the time the process is terminated.
     
167. 
     
168.         DWORD dwThreadId - Returns a global thread id that may be used
     
169.             to identify a thread.  The value is valid from the time the
     
170.             thread is created until the time the thread is terminated.
     
171. 
     
172.     hRestrictedUserToken - Returns a restricted token if a UsetToken was
     
173.         supplied. This is applicable for the CreateProcessAsUser case.
     
174.         The token is released by CreateProcessAsUser.
     
175. 
     
176. Return Value:
     
177. 
     
178.     TRUE - The operation was successful
     
179. 
     
180.     FALSE/NULL - The operation failed. Extended error status is available
     
181.         using GetLastError.
     
182. 
     
183. --*/
     
184. 
     
185. {
     
186.     NTSTATUS Status;
     
187.     OBJECT_ATTRIBUTES Obja;
     
188.     POBJECT_ATTRIBUTES pObja;
     
189.     HANDLE ProcessHandle, ThreadHandle, VdmWaitHandle = NULL;
     
190.     HANDLE FileHandle, SectionHandle;
     
191.     CLIENT_ID ClientId;
     
192.     UNICODE_STRING PathName;
     
193.     IO_STATUS_BLOCK IoStatusBlock;
     
194.     BOOLEAN TranslationStatus;
     
195.     RTL_RELATIVE_NAME RelativeName;
     
196.     PVOID FreeBuffer;
     
197.     LPWSTR NameBuffer;
     
198.     LPWSTR WhiteScan;
     
199.     ULONG Length,i;
     
200.     PROCESS_BASIC_INFORMATION ProcessInfo;
     
201.     SECTION_IMAGE_INFORMATION ImageInformation;
     
202.     NTSTATUS StackStatus;
     
203.     BOOLEAN bStatus;
     
204.     INITIAL_TEB InitialTeb;
     
205.     CONTEXT ThreadContext;
     
206.     PPEB Peb;
     
207.     BASE_API_MSG m;
     
208.     PBASE_CREATEPROCESS_MSG a = &m.u.CreateProcess;
     
209.     PBASE_CHECKVDM_MSG b = &m.u.CheckVDM;
     
210.     PWCH TempNull = NULL;
     
211.     WCHAR TempChar;
     
212.     UNICODE_STRING VdmNameString;
     
213.     PVOID BaseAddress;
     
214.     ULONG VdmReserve;
     
215.     SIZE_T BigVdmReserve;
     
216.     ULONG iTask=0;
     
217.     LPWSTR CurdirBuffer, CurdirFilePart;
     
218.     DWORD CurdirLength,CurdirLength2;
     
219.     ULONG VDMCreationState=0;
     
220.     ULONG VdmBinaryType = 0;
     
221.     BOOL  bMeowBinary = FALSE;
     
222.     UNICODE_STRING  SubSysCommandLine;
     
223.     PIMAGE_NT_HEADERS NtHeaders;
     
224.     DWORD dwNoWindow = (dwCreationFlags & CREATE_NO_WINDOW);
     
225.     ANSI_STRING AnsiStringVDMEnv;
     
226.     UNICODE_STRING UnicodeStringVDMEnv;
     
227.     WCHAR ImageFileDebuggerCommand[ MAX_PATH ];
     
228.     LPWSTR QuotedBuffer;
     
229.     BOOLEAN QuoteInsert;
     
230.     BOOLEAN QuoteCmdLine = FALSE;
     
231.     BOOLEAN QuoteFound;
     
232.     BOOL bSaferChecksNeeded = FALSE;
     
233.     BOOLEAN SearchRetry;
     
234.     BOOLEAN IsWowBinary = FALSE;
     
235.     STARTUPINFOW StartupInfo;
     
236.     DWORD LastError;
     
237.     DWORD fileattr;
     
238.     PROCESS_PRIORITY_CLASS PriClass;
     
239.     PVOID State;
     
240.     HANDLE DebugPortHandle = NULL;
     
241.     PVOID pAppCompatDataTemp;
     
242.     PVOID pAppCompatData  = NULL;
     
243.     DWORD cbAppCompatData = 0;    // for the future
     
244.     BOOLEAN bVdmRetry = FALSE;
     
245.     DWORD Flags;
     
246.     PVOID pAppCompatSxsData = NULL;
     
247.     DWORD cbAppCompatSxsData = 0;
     
248.     SXS_OVERRIDE_STREAM AppCompatSxsManifest;
     
249.     PCSR_CAPTURE_HEADER CaptureBuffer = NULL;
     
250.     SIZE_T SxsConglomeratedBufferSizeBytes;
     
251.     PBYTE SxsConglomeratedByteBuffer = NULL; // this contains all the of the below in one large right-sized heap allocation
     
252.                             // if we compute its size wrong, other code (if it gets it right..) should
     
253.                             // do more heap allocation
     
254.     ULONG sxsi; // for loop counter
     
255.     RTL_UNICODE_STRING_BUFFER SxsWin32ManifestPathBuffer;
     
256.     RTL_UNICODE_STRING_BUFFER SxsWin32PolicyPathBuffer;
     
257.     RTL_UNICODE_STRING_BUFFER SxsWin32AssemblyDirectoryBuffer;
     
258.     RTL_UNICODE_STRING_BUFFER SxsNtManifestPathBuffer;
     
259.     RTL_UNICODE_STRING_BUFFER SxsNtPolicyPathBuffer;
     
260.     const PRTL_UNICODE_STRING_BUFFER SxsStringBuffers[] = {
     
261.         // The order here does not matter.
     
262.         &SxsWin32ManifestPathBuffer,
     
263.         &SxsWin32PolicyPathBuffer,
     
264.         &SxsWin32AssemblyDirectoryBuffer,
     
265.         &SxsNtManifestPathBuffer,
     
266.         &SxsNtPolicyPathBuffer
     
267.     };
     
268.     UNICODE_STRING SxsWin32ExePath;
     
269.     UNICODE_STRING SxsNtExePath;
     
270.     BASE_MSG_SXS_HANDLES SxsExeHandles = {0};
     
271.     BASE_MSG_SXS_HANDLES SxsManifestFileHandles = {0};
     
272.     CONST SXS_CONSTANT_WIN32_NT_PATH_PAIR SxsExePathPair = { &SxsWin32ExePath, &SxsNtExePath };
     
273.     CONST SXS_WIN32_NT_PATH_PAIR SxsManifestPathPair = { &SxsWin32ManifestPathBuffer, &SxsNtManifestPathBuffer };
     
274.     CONST SXS_WIN32_NT_PATH_PAIR SxsPolicyPathPair = { &SxsWin32PolicyPathBuffer, &SxsNtPolicyPathBuffer };
     
275.     BASE_MSG_SXS_HANDLES SxsPolicyHandles = {0};
     
276.     PWSTR ExePathFullBuffer = NULL;
     
277. 
     
278.     DWORD dwJobMemberLevel = 0;
     
279.     HANDLE hSaferAssignmentJob = NULL;
     
280.     HANDLE hSaferRestrictedToken = NULL;
     
281. 
     
282.     DWORD dwBasePushProcessParametersFlags = 0;
     
283. 
     
284. #if defined(BUILD_WOW6432) || defined(_WIN64)
     
285.     BOOLEAN ComPlusILImage;
     
286.     LPCWSTR lpOriginalApplicationName = lpApplicationName;
     
287.     LPWSTR lpOriginalCommandLine = lpCommandLine;
     
288. #endif
     
289. 
     
290. #if defined(WX86)
     
291.     HANDLE Wx86Info = NULL;
     
292. #endif
     
293. 
     
294. #if defined WX86
     
295.     BOOLEAN UseKnownWx86Dll;
     
296.     UseKnownWx86Dll = NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll;
     
297.     NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = FALSE;
     
298. #endif
     
299. 
     
300.     RtlZeroMemory(&a->Sxs, sizeof(a->Sxs));
     
301.     RtlZeroMemory(lpProcessInformation,sizeof(*lpProcessInformation));
     
302. 
     
303.     if (ARGUMENT_PRESENT( hRestrictedUserToken )) {
     
304.         *hRestrictedUserToken = NULL;
     
305.         }
     
306. 
     
307.     // Private VDM flag should be ignored; Its meant for internal use only.
     
308.     dwCreationFlags &= (ULONG)~CREATE_NO_WINDOW;
     
309. 
     
310.     if ((dwCreationFlags & (DETACHED_PROCESS | CREATE_NEW_CONSOLE)) ==
     
311.         (DETACHED_PROCESS | CREATE_NEW_CONSOLE)) {
     
312. 
     
313.         SetLastError(ERROR_INVALID_PARAMETER);
     
314.         return FALSE;
     
315.         }
     
316. 
     
317.     AnsiStringVDMEnv.Buffer = NULL;
     
318.     UnicodeStringVDMEnv.Buffer = NULL;
     
319. 
     
320.     //
     
321.     // the lowest specified priority class is used.
     
322.     //
     
323. 
     
324.     if (dwCreationFlags & IDLE_PRIORITY_CLASS ) {
     
325.         PriClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
     
326.         }
     
327.     else if (dwCreationFlags & BELOW_NORMAL_PRIORITY_CLASS ) {
     
328.         PriClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
     
329.         }
     
330.     else if (dwCreationFlags & NORMAL_PRIORITY_CLASS ) {
     
331.         PriClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
     
332.         }
     
333.     else if (dwCreationFlags & ABOVE_NORMAL_PRIORITY_CLASS ) {
     
334.         PriClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
     
335.         }
     
336.     else if (dwCreationFlags & HIGH_PRIORITY_CLASS ) {
     
337.         PriClass.PriorityClass =  PROCESS_PRIORITY_CLASS_HIGH;
     
338.         }
     
339.     else if (dwCreationFlags & REALTIME_PRIORITY_CLASS ) {
     
340.         if ( BasepIsRealtimeAllowed(FALSE) ) {
     
341.             PriClass.PriorityClass =  PROCESS_PRIORITY_CLASS_REALTIME;
     
342.             }
     
343.         else {
     
344.             PriClass.PriorityClass =  PROCESS_PRIORITY_CLASS_HIGH;
     
345.             }
     
346.         }
     
347.     else {
     
348.         PriClass.PriorityClass = PROCESS_PRIORITY_CLASS_UNKNOWN;
     
349.         }
     
350.     PriClass.Foreground = FALSE;
     
351. 
     
352.     dwCreationFlags = (dwCreationFlags & ~PRIORITY_CLASS_MASK );
     
353. 
     
354.     //
     
355.     // Default separate/shared VDM option if not explicitly specified.
     
356.     //
     
357. 
     
358.     if (dwCreationFlags & CREATE_SEPARATE_WOW_VDM) {
     
359.         if (dwCreationFlags & CREATE_SHARED_WOW_VDM) {
     
360.             SetLastError(ERROR_INVALID_PARAMETER);
     
361. 
     
362.             return FALSE;
     
363.             }
     
364.         }
     
365.     else
     
366.     if ((dwCreationFlags & CREATE_SHARED_WOW_VDM) == 0) {
     
367.         if (BaseStaticServerData->DefaultSeparateVDM) {
     
368.             dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
     
369.             }
     
370.         }
     
371. 
     
372.     if ((dwCreationFlags & CREATE_SEPARATE_WOW_VDM) == 0) {
     
373.         //
     
374.         // If the creator is running inside a job object, always
     
375.         // set SEPERATE_WOW_VDM so the VDM is part of the job.
     
376.         //
     
377.         JOBOBJECT_BASIC_UI_RESTRICTIONS UiRestrictions;
     
378. 
     
379.         Status = NtQueryInformationJobObject(NULL,
     
380.                                              JobObjectBasicUIRestrictions,
     
381.                                              &UiRestrictions,
     
382.                                              sizeof(UiRestrictions),
     
383.                                              NULL);
     
384.         if (Status != STATUS_ACCESS_DENIED) {
     
385.             //
     
386.             // Anything other than STATUS_ACCESS_DENIED indicates the
     
387.             // current process is inside a job.
     
388.             //
     
389.             dwCreationFlags = (dwCreationFlags & (~CREATE_SHARED_WOW_VDM)) |
     
390.                                   CREATE_SEPARATE_WOW_VDM;
     
391.             }
     
392.         }
     
393. 
     
394. 
     
395.     //
     
396.     //  If ANSI environment, convert to Unicode
     
397.     //
     
398. 
     
399.     if (lpEnvironment && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT) ) {
     
400.         PUCHAR s;
     
401.         STRING Ansi;
     
402.         UNICODE_STRING Unicode;
     
403.         MEMORY_BASIC_INFORMATION MemoryInformation;
     
404. 
     
405.         Ansi.Buffer = s = lpEnvironment;
     
406.         while (*s || *(s+1))            // find end of block
     
407.             s++;
     
408. 
     
409.         Ansi.Length = (USHORT)(s - Ansi.Buffer) + 1;
     
410.         Ansi.MaximumLength = Ansi.Length + 1;
     
411.         MemoryInformation.RegionSize = Ansi.MaximumLength * sizeof(WCHAR);
     
412.         Unicode.Buffer = NULL;
     
413.         Status = NtAllocateVirtualMemory( NtCurrentProcess(),
     
414.                                           &Unicode.Buffer,
     
415.                                           0,
     
416.                                           &MemoryInformation.RegionSize,
     
417.                                           MEM_COMMIT,
     
418.                                           PAGE_READWRITE
     
419.                                         );
     
420.         if (!NT_SUCCESS(Status) ) {
     
421.             BaseSetLastNTError(Status);
     
422. 
     
423.             return FALSE;
     
424.             }
     
425. 
     
426.         Unicode.MaximumLength = (USHORT)MemoryInformation.RegionSize;
     
427.         Status = RtlAnsiStringToUnicodeString(&Unicode, &Ansi, FALSE);
     
428.         if (!NT_SUCCESS(Status) ) {
     
429.             NtFreeVirtualMemory( NtCurrentProcess(),
     
430.                                  &Unicode.Buffer,
     
431.                                  &MemoryInformation.RegionSize,
     
432.                                  MEM_RELEASE
     
433.                                );
     
434.             BaseSetLastNTError(Status);
     
435. 
     
436.             return FALSE;
     
437.             }
     
438.         lpEnvironment = Unicode.Buffer;
     
439.         }
     
440. 
     
441.     FileHandle = NULL;
     
442.     SectionHandle = NULL;
     
443.     ProcessHandle = NULL;
     
444.     ThreadHandle = NULL;
     
445.     FreeBuffer = NULL;
     
446.     NameBuffer = NULL;
     
447.     VdmNameString.Buffer = NULL;
     
448.     BaseAddress = (PVOID)1;
     
449.     VdmReserve = 0;
     
450.     CurdirBuffer = NULL;
     
451.     CurdirFilePart = NULL;
     
452.     SubSysCommandLine.Buffer = NULL;
     
453.     QuoteFound = FALSE;
     
454.     QuoteInsert = FALSE;
     
455.     QuotedBuffer = NULL;
     
456. 
     
457.     try {
     
458. 
     
459.         //
     
460.         // Make a copy of the startup info so we can change it.
     
461.         //
     
462. 
     
463.         StartupInfo = *lpStartupInfo;
     
464. 
     
465.         //
     
466.         // STARTF_USEHOTKEY means hStdInput is really the hotkey value.
     
467.         // STARTF_HASSHELLDATA means std handles are used for shell-private
     
468.         // data.  This flag is used if an icon is passed to ShellExecuteEx.
     
469.         // As a result they cannot be specified with STARTF_USESTDHANDLES.
     
470.         // Consistent with Win95, USESTDHANDLES is ignored.
     
471.         //
     
472. 
     
473.         if (StartupInfo.dwFlags & STARTF_USESTDHANDLES &&
     
474.             StartupInfo.dwFlags & (STARTF_USEHOTKEY | STARTF_HASSHELLDATA)) {
     
475. 
     
476.             StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
     
477.             }
     
478. 
     
479. VdmRetry:
     
480.         //
     
481.         // None of this cleanup/reinit occurs for launching a Win32 or Win64 .exe,
     
482.         // but they generally do occur for launching 16bit, .bat, etc.
     
483.         //
     
484.         if (NameBuffer) {
     
485.             RtlFreeHeap(RtlProcessHeap(), 0, NameBuffer);
     
486.             NameBuffer = NULL;
     
487.         }
     
488.         if (FreeBuffer) {
     
489.             RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
     
490.             FreeBuffer = NULL;
     
491.         }
     
492.         if (FileHandle) {
     
493.             NtClose(FileHandle);
     
494.             FileHandle = NULL;
     
495.         }
     
496. 
     
497.         LastError = 0;
     
498.         SearchRetry = TRUE;
     
499.         QuoteInsert = FALSE;
     
500.         QuoteCmdLine = FALSE;
     
501.         if (!ARGUMENT_PRESENT( lpApplicationName )) {
     
502. 
     
503.             //
     
504.             // Locate the image
     
505.             //
     
506. 
     
507.             // forgot to free NameBuffer before goto VdmRetry???
     
508.             ASSERT(NameBuffer == NULL);
     
509. 
     
510.             NameBuffer = RtlAllocateHeap( RtlProcessHeap(),
     
511.                                           MAKE_TAG( TMP_TAG ),
     
512.                                           MAX_PATH * sizeof( WCHAR ));
     
513.             if ( !NameBuffer ) {
     
514.                 BaseSetLastNTError(STATUS_NO_MEMORY);
     
515.                 return FALSE;
     
516.                 }
     
517.             lpApplicationName = lpCommandLine;
     
518.             TempNull = (PWCH)lpApplicationName;
     
519.             WhiteScan = (LPWSTR)lpApplicationName;
     
520. 
     
521.             //
     
522.             // check for lead quote
     
523.             //
     
524.             if ( *WhiteScan == L'"' ) {
     
525.                 SearchRetry = FALSE;
     
526.                 WhiteScan++;
     
527.                 lpApplicationName = WhiteScan;
     
528.                 while(*WhiteScan) {
     
529.                     if ( *WhiteScan == (WCHAR)'"' ) {
     
530.                         TempNull = (PWCH)WhiteScan;
     
531.                         QuoteFound = TRUE;
     
532.                         break;
     
533.                         }
     
534.                     WhiteScan++;
     
535.                     TempNull = (PWCH)WhiteScan;
     
536.                     }
     
537.                 }
     
538.             else {
     
539. retrywsscan:
     
540.                 lpApplicationName = lpCommandLine;
     
541.                 while(*WhiteScan) {
     
542.                     if ( *WhiteScan == (WCHAR)' ' ||
     
543.                          *WhiteScan == (WCHAR)'\t' ) {
     
544.                         TempNull = (PWCH)WhiteScan;
     
545.                         break;
     
546.                         }
     
547.                     WhiteScan++;
     
548.                     TempNull = (PWCH)WhiteScan;
     
549.                     }
     
550.                 }
     
551.             TempChar = *TempNull;
     
552.             *TempNull = UNICODE_NULL;
     
553. 
     
554. #ifdef WX86
     
555. 
     
556.             //
     
557.             // Wx86 applications must use x86 version of known exes
     
558.             // for compatibility.
     
559.             //
     
560. 
     
561.             if (UseKnownWx86Dll) {
     
562.                LPWSTR KnownName;
     
563. 
     
564.                NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = FALSE;
     
565. 
     
566.                KnownName = BasepWx86KnownExe(lpApplicationName);
     
567.                if (KnownName) {
     
568.                   lpApplicationName = KnownName;
     
569.                   }
     
570.                }
     
571. #endif
     
572. 
     
573. 
     
574.             Length = SearchPathW(
     
575.                         NULL,
     
576.                         lpApplicationName,
     
577.                         L".exe",
     
578.                         MAX_PATH,
     
579.                         NameBuffer,
     
580.                         NULL
     
581.                         )*2;
     
582. 
     
583.             if (Length != 0 && Length < MAX_PATH * sizeof( WCHAR )) {
     
584.                 //
     
585.                 // SearchPathW worked, but file might be a directory
     
586.                 // if this happens, we need to keep trying
     
587.                 //
     
588.                 fileattr = GetFileAttributesW(NameBuffer);
     
589.                 if ( fileattr != 0xffffffff &&
     
590.                      (fileattr & FILE_ATTRIBUTE_DIRECTORY) ) {
     
591.                     Length = 0;
     
592.                 } else {
     
593.                     Length++;
     
594.                     Length++;
     
595.                 }
     
596.             }
     
597. 
     
598.             if ( !Length || Length >= MAX_PATH<<1 ) {
     
599. 
     
600.                 //
     
601.                 // If we search pathed, then return file not found.
     
602.                 // otherwise, try to be more specific.
     
603.                 //
     
604.                 RTL_PATH_TYPE PathType;
     
605.                 HANDLE hFile;
     
606. 
     
607.                 PathType = RtlDetermineDosPathNameType_U(lpApplicationName);
     
608.                 if ( PathType != RtlPathTypeRelative ) {
     
609. 
     
610.                     //
     
611.                     // The failed open should set get last error properly.
     
612.                     //
     
613. 
     
614.                     hFile = CreateFileW(
     
615.                                 lpApplicationName,
     
616.                                 GENERIC_READ,
     
617.                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
     
618.                                 NULL,
     
619.                                 OPEN_EXISTING,
     
620.                                 FILE_ATTRIBUTE_NORMAL,
     
621.                                 NULL
     
622.                                 );
     
623.                     if ( hFile != INVALID_HANDLE_VALUE ) {
     
624.                         CloseHandle(hFile);
     
625.                         BaseSetLastNTError(STATUS_OBJECT_NAME_NOT_FOUND);
     
626.                         }
     
627.                     }
     
628.                 else {
     
629.                     BaseSetLastNTError(STATUS_OBJECT_NAME_NOT_FOUND);
     
630.                     }
     
631. 
     
632.                 //
     
633.                 // remember initial last error value for the retry scan path
     
634.                 //
     
635. 
     
636.                 if ( LastError ) {
     
637.                     SetLastError(LastError);
     
638.                     }
     
639.                 else {
     
640.                     LastError = GetLastError();
     
641.                     }
     
642. 
     
643.                 //
     
644.                 // restore the command line
     
645.                 //
     
646. 
     
647.                 *TempNull = TempChar;
     
648.                 lpApplicationName = NameBuffer;
     
649. 
     
650.                 //
     
651.                 // If we still have command line left, then keep going
     
652.                 // the point is to march through the command line looking
     
653.                 // for whitespace so we can try to find an image name
     
654.                 // launches of things like:
     
655.                 // c:\word 95\winword.exe /embedding -automation
     
656.                 // require this. Our first iteration will stop at c:\word, our next
     
657.                 // will stop at c:\word 95\winword.exe
     
658.                 //
     
659.                 if (*WhiteScan && SearchRetry) {
     
660.                     WhiteScan++;
     
661.                     TempNull = WhiteScan;
     
662.                     QuoteInsert = TRUE;
     
663.                     QuoteFound = TRUE;
     
664.                     goto retrywsscan;
     
665.                 }
     
666. 
     
667.                 return FALSE;
     
668.                 }
     
669.             //
     
670.             // restore the command line
     
671.             //
     
672. 
     
673.             *TempNull = TempChar;
     
674.             lpApplicationName = NameBuffer;
     
675. 
     
676.             //
     
677.             // check whether it is setup.exe started by winlogon.exe
     
678.             //
     
679.             if (BasepIsSetupInvokedByWinLogon(lpApplicationName))
     
680.             {
     
681.                 // validate the flag
     
682.                 if (!(dwCreationFlags & CREATE_IGNORE_SYSTEM_DEFAULT))
     
683.                 {
     
684.                     //
     
685.                     // BUGBUBGUBGUBUGBUGBUGUBGBUGUBGUB
     
686.                     //    Winlogon does not set the flag correctly
     
687.                     //    in phase1, ignore it(now)
     
688.                     //    in phase2, ASSERT it
     
689.                     // BUGBUBGUBGUBUGBUGBUGUBGBUGUBGUB
     
690.                     //
     
691.                     dwCreationFlags |= CREATE_IGNORE_SYSTEM_DEFAULT;
     
692.                 }
     
693.             }
     
694.             
     
695.         }
     
696.         else
     
697.         if (!ARGUMENT_PRESENT( lpCommandLine ) || *lpCommandLine == UNICODE_NULL ) {
     
698.             QuoteCmdLine = TRUE;
     
699.             lpCommandLine = (LPWSTR)lpApplicationName;
     
700.             }
     
701. 
     
702. 
     
703. #ifdef WX86
     
704. 
     
705.        //
     
706.        // Wx86 applications must use x86 version of known exes
     
707.        // for compatibility.
     
708.        //
     
709. 
     
710.        if (UseKnownWx86Dll) {
     
711.            LPWSTR KnownName;
     
712. 
     
713.            NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = FALSE;
     
714. 
     
715.            KnownName = BasepWx86KnownExe(lpApplicationName);
     
716.            if (KnownName) {
     
717. 
     
718.                RtlFreeHeap(RtlProcessHeap(), 0, NameBuffer);
     
719.                NameBuffer = KnownName;
     
720.                lpApplicationName = KnownName;
     
721.                }
     
722.            }
     
723. 
     
724. #endif
     
725. 
     
726.         //
     
727.         // Translate to an NT name.
     
728.         //
     
729. 
     
730.         TranslationStatus = RtlDosPathNameToNtPathName_U(
     
731.                                 lpApplicationName,
     
732.                                 &PathName,
     
733.                                 NULL,
     
734.                                 &RelativeName
     
735.                                 );
     
736. 
     
737.         if ( !TranslationStatus ) {
     
738.             SetLastError(ERROR_PATH_NOT_FOUND);
     
739. 
     
740.             return FALSE;
     
741.             }
     
742. 
     
743.         // forgot to free FreeBuffer before goto VdmRetry????
     
744.         ASSERT(FreeBuffer == NULL);
     
745.         FreeBuffer = PathName.Buffer;
     
746. 
     
747.         RtlInitUnicodeString(&SxsWin32ExePath, lpApplicationName);
     
748. 
     
749.         {
     
750.             RTL_PATH_TYPE SxsWin32ExePathType = RtlDetermineDosPathNameType_U(lpApplicationName);
     
751. 
     
752.             if ((SxsWin32ExePathType != RtlPathTypeDriveAbsolute) &&
     
753.                 (SxsWin32ExePathType != RtlPathTypeUncAbsolute)) {
     
754.                 if (ExePathFullBuffer == NULL) {
     
755.                     // It seems that with VDM things, we can rerun this code with a new lpApplication, so
     
756.                     // we protect against double-allocating the buffer and just allocate a big
     
757.                     // MAX_PATH one the first time through, assuming it's good enough for the 2ndary times
     
758.                     // too.
     
759.                     ExePathFullBuffer = RtlAllocateHeap(RtlProcessHeap(), 0, (MAX_PATH + 1) * sizeof(WCHAR));
     
760.                     if (ExePathFullBuffer == NULL) {
     
761.                         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     
762.                         return FALSE;
     
763.                     }
     
764.                 }
     
765. 
     
766.                 RtlGetFullPathName_U(lpApplicationName, (MAX_PATH + 1) * sizeof(WCHAR), ExePathFullBuffer, NULL);
     
767. 
     
768.                 RtlInitUnicodeString(&SxsWin32ExePath, ExePathFullBuffer);
     
769.             }
     
770.         }
     
771. 
     
772. 
     
773.         SxsNtExePath = PathName;
     
774. 
     
775.         if ( RelativeName.RelativeName.Length ) {
     
776.             PathName = *(PUNICODE_STRING)&RelativeName.RelativeName;
     
777.             }
     
778.         else {
     
779.             RelativeName.ContainingDirectory = NULL;
     
780.             }
     
781. 
     
782.         InitializeObjectAttributes(
     
783.             &Obja,
     
784.             &PathName,
     
785.             OBJ_CASE_INSENSITIVE,
     
786.             RelativeName.ContainingDirectory,
     
787.             NULL
     
788.             );
     
789. 
     
790.         //
     
791.         // Open the file for red and execute access
     
792.         //
     
793. 
     
794.         Status = NtOpenFile(
     
795.                     &FileHandle,
     
796.                     SYNCHRONIZE | FILE_EXECUTE | FILE_READ_ATTRIBUTES | FILE_READ_DATA,
     
797.                     &Obja,
     
798.                     &IoStatusBlock,
     
799.                     FILE_SHARE_READ | FILE_SHARE_DELETE,
     
800.                     FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
     
801.                     );
     
802. 
     
803.         if (!NT_SUCCESS(Status) ) {
     
804. 
     
805.             //
     
806.             // We failed. Open the file for lesser access.
     
807.             //
     
808. 
     
809.             Status = NtOpenFile(
     
810.                         &FileHandle,
     
811.                         SYNCHRONIZE | FILE_EXECUTE,
     
812.                         &Obja,
     
813.                         &IoStatusBlock,
     
814.                         FILE_SHARE_READ | FILE_SHARE_DELETE,
     
815.                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
     
816.                         );
     
817. 
     
818.             if (!NT_SUCCESS(Status) ) {
     
819.                 //
     
820.                 // if we failed, see if this is a device. If it is a device,
     
821.                 // then just return invalid image format
     
822.                 //
     
823. 
     
824.                 if ( RtlIsDosDeviceName_U(RTL_CONST_CAST(PWSTR)(lpApplicationName)) ) {
     
825.                     SetLastError(ERROR_BAD_DEVICE);
     
826.                     }
     
827.                 else {
     
828.                     BaseSetLastNTError(Status);
     
829.                     }
     
830. 
     
831.                 return FALSE;
     
832.             }
     
833. 
     
834.         }
     
835. 
     
836.         //
     
837.         // If no desktop has been specified, use the caller's
     
838.         // desktop.
     
839.         //
     
840. 
     
841.         if (StartupInfo.lpDesktop == NULL) {
     
842.             StartupInfo.lpDesktop =
     
843.                     (LPWSTR)((PRTL_USER_PROCESS_PARAMETERS)NtCurrentPeb()->
     
844.                         ProcessParameters)->DesktopInfo.Buffer;
     
845.             }
     
846. 
     
847.         //
     
848.         // Create a section object backed by the file
     
849.         //
     
850. 
     
851.         Status = NtCreateSection(
     
852.                     &SectionHandle,
     
853.                     SECTION_ALL_ACCESS,
     
854.                     NULL,
     
855.                     NULL,
     
856.                     PAGE_EXECUTE,
     
857.                     SEC_IMAGE,
     
858.                     FileHandle
     
859.                     );
     
860. 
     
861.         //
     
862.         // App Certification DLL
     
863.         //
     
864. 
     
865.         if (NT_SUCCESS(Status)) {
     
866.             Status = BasepIsProcessAllowed(lpApplicationName);
     
867. 
     
868.             if (!NT_SUCCESS(Status)) {
     
869.                 BaseSetLastNTError(Status);
     
870.                 NtClose(SectionHandle);
     
871.                 return FALSE;
     
872.             }
     
873. 
     
874. 
     
875.       
     
876.           //
     
877.           // If Meow subsystem is enabled and caller specified CREATE_FORECEDOS for a win32 image
     
878.           // push it into the meow subsystem
     
879.           //
     
880. 
     
881.           if ((dwCreationFlags & CREATE_FORCEDOS) && BaseStaticServerData->ForceDos) {
     
882.                dwCreationFlags &= ~(CREATE_SHARED_WOW_VDM | CREATE_FORCEDOS);
     
883.                dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
     
884.                Status = STATUS_INVALID_IMAGE_WIN_16;
     
885.                bMeowBinary = TRUE;
     
886. 
     
887.                NtClose(SectionHandle);
     
888.                SectionHandle = NULL;
     
889.           }
     
890. 
     
891. 
     
892.        }
     
893. 
     
894.         //
     
895.         // check appcompat (aka apphelp)
     
896.         //
     
897.         // if we are running under debugger, bVdmRetry will be FALSE
     
898.         // yet pAppCompatData may have some data (from the app itself)
     
899.         // debugger will do a separate CreateProcess on debugee
     
900.         //
     
901.         // apphelp gets called if it is win32 app or if it is a .bat or .cmd
     
902. 
     
903.        if(!bVdmRetry &&
     
904.           (NT_SUCCESS(Status) ||
     
905.            (Status == STATUS_INVALID_IMAGE_NOT_MZ && !BaseIsDosApplication(&PathName,Status)))
     
906.          ) {
     
907.             NTSTATUS BadAppStatus;
     
908. 
     
909.             if (NULL != pAppCompatData) {
     
910.                 RtlFreeHeap(RtlProcessHeap(), 0, pAppCompatData);
     
911.                 pAppCompatData = NULL;
     
912.                 }
     
913.               
     
914.             if (NULL != pAppCompatSxsData) {
     
915.                 RtlFreeHeap(RtlProcessHeap(), 0, pAppCompatSxsData);
     
916.                 pAppCompatSxsData = NULL;
     
917.                 }
     
918.             
     
919.             //
     
920.             // we only check ONCE --
     
921.             // the second time around is rather meaningless - to check for posix/ntvdm/os2 emulation
     
922.             //
     
923.             BadAppStatus = BasepCheckBadapp(FileHandle,
     
924.                                             PathName.Buffer,
     
925.                                             (WCHAR*)lpEnvironment,
     
926.                                             &pAppCompatData,
     
927.                                             &cbAppCompatData,
     
928.                                             &pAppCompatSxsData,
     
929.                                             &cbAppCompatSxsData);
     
930.                     
     
931.             if (!NT_SUCCESS(BadAppStatus)) {
     
932.                 if (BadAppStatus == STATUS_ACCESS_DENIED) {
     
933.                     SetLastError(ERROR_CANCELLED);
     
934.                     }
     
935.                 else {
     
936.                     BaseSetLastNTError(BadAppStatus);
     
937.                     }
     
938. 
     
939.                 if (SectionHandle) {
     
940.                     NtClose(SectionHandle);
     
941.                     SectionHandle = NULL;
     
942.                     }
     
943.                 return FALSE;
     
944.                 }
     
945.             }
     
946. 
     
947.        //
     
948.        // Winsafer code
     
949.        //
     
950.        // If this is the first time then we will have to do Safer checks.
     
951.        // Note that we do not impose any restrictions on the interpreter
     
952.        // itself since it is part of OS.
     
953.        //
     
954. 
     
955. 
     
956.        if ((!bVdmRetry) &&
     
957.            ( (dwCreationFlags & CREATE_PRESERVE_CODE_AUTHZ_LEVEL) == 0 )) {
     
958. 
     
959.            NTSTATUS SaferStatus;
     
960. 
     
961. 
     
962.            {
     
963. 
     
964.                //
     
965.                // WinSafer process sandbox restrictions handling.
     
966.                // Should be done for non .NET images only.
     
967.                //
     
968. 
     
969.                SaferStatus = BasepCheckWinSaferRestrictions(
     
970.                                                       hUserToken,
     
971.                                                       lpApplicationName,   // same as PathName.Buffer
     
972.                                                       FileHandle,
     
973.                                                       &dwJobMemberLevel,
     
974.                                                       &hSaferRestrictedToken,
     
975.                                                       &hSaferAssignmentJob);
     
976.                if (SaferStatus == -1) {
     
977.                    SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
     
978.                    bStatus =  FALSE;
     
979.                    leave;
     
980.                } else if (!NT_SUCCESS(SaferStatus)) {
     
981.                    BaseSetLastNTError(SaferStatus);
     
982.                    bStatus = FALSE;
     
983.                    leave;
     
984.                }
     
985.            }
     
986.        }
     
987. 
     
988. 
     
989.         if (!NT_SUCCESS(Status)) {
     
990.             switch (Status) {
     
991.                 // 16 bit OS/2 exe
     
992.                 case STATUS_INVALID_IMAGE_NE_FORMAT:
     
993. #if defined(i386) && defined(OS2_SUPPORT_ENABLED)
     
994.                 //
     
995.                 // Use OS/2 if x86 (OS/2 not supported on risc),
     
996.                 //    and CreationFlags don't have forcedos bit
     
997.                 //    and Registry didn't specify ForceDos
     
998.                 //
     
999.                 // else execute as a DOS bound app.
     
1000.                 //
      
1001.                 //
      
1002. 
      
1003.                 if (!(dwCreationFlags & CREATE_FORCEDOS) &&
      
1004.                     !BaseStaticServerData->ForceDos)
      
1005.                   {
      
1006. 
      
1007.                     if ( !BuildSubSysCommandLine( L"OS2 /P ",
      
1008.                                                   lpApplicationName,
      
1009.                                                   lpCommandLine,
      
1010.                                                   &SubSysCommandLine
      
1011.                                                 ) ) {
      
1012.                         return FALSE;
      
1013.                         }
      
1014. 
      
1015.                     lpCommandLine = SubSysCommandLine.Buffer;
      
1016. 
      
1017.                     lpApplicationName = NULL;
      
1018. 
      
1019.                     bVdmRetry = TRUE;
      
1020.                     goto VdmRetry;
      
1021.                     }
      
1022. #endif
      
1023.                     // Falls into Dos case, so that stub message will be
      
1024.                     // printed, and bound apps will run w/o OS/2 subsytem
      
1025. 
      
1026.                 // Dos .exe or .com
      
1027. 
      
1028.                 case STATUS_INVALID_IMAGE_PROTECT:
      
1029.                 case STATUS_INVALID_IMAGE_NOT_MZ:
      
1030. ForceDos:
      
1031.                     {
      
1032.                     ULONG BinarySubType;
      
1033. 
      
1034.                     BinarySubType = BINARY_TYPE_DOS_EXE;
      
1035.                     if (Status == STATUS_INVALID_IMAGE_PROTECT   ||
      
1036.                         Status == STATUS_INVALID_IMAGE_NE_FORMAT ||
      
1037.                        (BinarySubType = BaseIsDosApplication(&PathName,Status)) )
      
1038.                        {
      
1039. #if defined(_WIN64) || defined(BUILD_WOW6432)
      
1040.                         //
      
1041.                         // If this a DOS application, then we need to pop up a dialog
      
1042.                         // saying that this an invalid win32 application.
      
1043.                         //
      
1044.                         goto RaiseInvalidWin32Error;
      
1045. #endif
      
1046.                         VdmBinaryType = BINARY_TYPE_DOS;
      
1047. 
      
1048.                         // create the environment before going to the
      
1049.                         // server. This was done becuase we want NTVDM
      
1050.                         // to have the new environment when it gets
      
1051.                         // created.
      
1052.                         if (!BaseCreateVDMEnvironment(
      
1053.                                     lpEnvironment,
      
1054.                                     &AnsiStringVDMEnv,
      
1055.                                     &UnicodeStringVDMEnv
      
1056.                                     )) {
      
1057.                             return FALSE;
      
1058.                         }
      
1059. 
      
1060.                         if(!BaseCheckVDM(VdmBinaryType | BinarySubType,
      
1061.                                          lpApplicationName,
      
1062.                                          lpCommandLine,
      
1063.                                          lpCurrentDirectory,
      
1064.                                          &AnsiStringVDMEnv,
      
1065.                                          &m,
      
1066.                                          &iTask,
      
1067.                                          dwCreationFlags,
      
1068.                                          &StartupInfo
      
1069.                                          )) {
      
1070. 
      
1071.                             return FALSE;
      
1072.                         }
      
1073. 
      
1074.                         // Check the return value from the server
      
1075.                         switch (b->VDMState & VDM_STATE_MASK) {
      
1076.                             case VDM_NOT_PRESENT:
      
1077.                                 // mark this so the server can undo
      
1078.                                 // creation if something goes wrong.
      
1079.                                 // We marked it "partially created" because
      
1080.                                 // the NTVDM has yet not been fully created.
      
1081.                                 // a call to UpdateVdmEntry to update
      
1082.                                 // process handle will signal the NTVDM
      
1083.                                 // process completed creation
      
1084.                                 VDMCreationState = VDM_PARTIALLY_CREATED;
      
1085.                                 // fail the call if NTVDM process is being
      
1086.                                 // created DETACHED.
      
1087.                                 // note that, we let it go if NTVDM process
      
1088.                                 // is already running.
      
1089.                                 if (dwCreationFlags & DETACHED_PROCESS) {
      
1090.                                     SetLastError(ERROR_ACCESS_DENIED);
      
1091.                                     return FALSE;
      
1092.                                     }
      
1093.                                 if (!BaseGetVdmConfigInfo(lpCommandLine,
      
1094.                                                           iTask,
      
1095.                                                           VdmBinaryType,
      
1096.                                                           &VdmNameString,
      
1097.                                                           &VdmReserve)) {
      
1098.                                     BaseSetLastNTError(Status);
      
1099.                                     return FALSE;
      
1100.                                     }
      
1101. 
      
1102.                                 lpCommandLine = VdmNameString.Buffer;
      
1103.                                 lpApplicationName = NULL;
      
1104. 
      
1105.                                 break;
      
1106. 
      
1107.                             case VDM_PRESENT_NOT_READY:
      
1108.                                 SetLastError (ERROR_NOT_READY);
      
1109.                                 return FALSE;
      
1110. 
      
1111.                             case VDM_PRESENT_AND_READY:
      
1112.                                 VDMCreationState = VDM_BEING_REUSED;
      
1113.                                 VdmWaitHandle = b->WaitObjectForParent;
      
1114.                                 break;
      
1115.                             }
      
1116.                          VdmReserve--;               // we reserve from addr 1
      
1117.                          if(VdmWaitHandle)
      
1118.                             goto VdmExists;
      
1119.                          else{
      
1120.                             bInheritHandles = FALSE;
      
1121.                             if (lpEnvironment &&
      
1122.                                 !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT)){
      
1123.                                 RtlDestroyEnvironment(lpEnvironment);
      
1124.                                 }
      
1125.                             lpEnvironment = UnicodeStringVDMEnv.Buffer;
      
1126.                             bVdmRetry = TRUE;
      
1127.                             goto VdmRetry;
      
1128.                             }
      
1129.                         }
      
1130.                     else {
      
1131. 
      
1132.                         //
      
1133.                         //  must be a .bat or .cmd file
      
1134.                         //
      
1135. 
      
1136.                         static PWCHAR CmdPrefix = L"cmd /c ";
      
1137.                         PWCHAR NewCommandLine;
      
1138.                         ULONG Length;
      
1139.                         PWCHAR Last4 = &PathName.Buffer[PathName.Length / sizeof( WCHAR )-4];
      
1140. 
      
1141.                         if ( PathName.Length < 8 ) {
      
1142.                             SetLastError(ERROR_BAD_EXE_FORMAT);
      
1143.                             return FALSE;
      
1144.                             }
      
1145. 
      
1146.                         if (_wcsnicmp( Last4, L".bat", 4 ) && _wcsnicmp( Last4, L".cmd", 4 )) {
      
1147.                             SetLastError(ERROR_BAD_EXE_FORMAT);
      
1148.                             return FALSE;
      
1149.                         }
      
1150. 
      
1151.                         Length = wcslen( CmdPrefix )
      
1152.                                  + (QuoteCmdLine || QuoteFound )
      
1153.                                  + wcslen( lpCommandLine )
      
1154.                                  + (QuoteCmdLine || QuoteFound)
      
1155.                                  + 1;
      
1156. 
      
1157.                         NewCommandLine = RtlAllocateHeap( RtlProcessHeap( ),
      
1158.                                                           MAKE_TAG( TMP_TAG ),
      
1159.                                                           Length * sizeof( WCHAR ) );
      
1160. 
      
1161.                         if (NewCommandLine == NULL) {
      
1162.                             BaseSetLastNTError(STATUS_NO_MEMORY);
      
1163.                             return FALSE;
      
1164.                         }
      
1165. 
      
1166.                         wcscpy( NewCommandLine, CmdPrefix );
      
1167.                         if (QuoteCmdLine || QuoteFound) {
      
1168.                             wcscat( NewCommandLine, L""" );
      
1169.                         }
      
1170.                         wcscat( NewCommandLine, lpCommandLine );
      
1171.                         if (QuoteCmdLine || QuoteFound) {
      
1172.                             wcscat( NewCommandLine, L""" );
      
1173.                         }
      
1174. 
      
1175.                         RtlInitUnicodeString( &SubSysCommandLine, NewCommandLine );
      
1176. 
      
1177.                         lpCommandLine = SubSysCommandLine.Buffer;
      
1178. 
      
1179.                         lpApplicationName = NULL;
      
1180. 
      
1181.                         bVdmRetry = TRUE;
      
1182.                         goto VdmRetry;
      
1183. 
      
1184.                         }
      
1185. 
      
1186.                     }
      
1187. 
      
1188.                 // 16 bit windows exe
      
1189.                 case STATUS_INVALID_IMAGE_WIN_16:
      
1190. #if defined(BUILD_WOW6432) || defined(_WIN64)
      
1191.                    if (lpOriginalApplicationName == NULL) {
      
1192.                        // pass in the part of the command line after the exe name
      
1193.                        // including whitespace
      
1194.                        lpCommandLine = ((*TempNull == '"') ? TempNull + 1 : TempNull);
      
1195.                    } else {
      
1196.                        lpCommandLine = lpOriginalCommandLine;
      
1197.                    }
      
1198. 
      
1199.                    return NtVdm64CreateProcess(lpOriginalApplicationName == NULL,
      
1200.                                                lpApplicationName,             // this is now the real file name we've loaded
      
1201.                                                lpCommandLine,
      
1202.                                                lpProcessAttributes,
      
1203.                                                lpThreadAttributes,
      
1204.                                                bInheritHandles,
      
1205.                                                (dwCreationFlags & ~CREATE_UNICODE_ENVIRONMENT),  // the environment has already been converted to unicode
      
1206.                                                lpEnvironment,
      
1207.                                                lpCurrentDirectory,
      
1208.                                                lpStartupInfo,
      
1209.                                                lpProcessInformation
      
1210.                                                );
      
1211. #endif
      
1212.                    if (dwCreationFlags & CREATE_FORCEDOS) {
      
1213.                        goto ForceDos;
      
1214.                        }
      
1215. 
      
1216.                     IsWowBinary = TRUE;
      
1217.                     if (!BaseCreateVDMEnvironment(lpEnvironment,
      
1218.                                                   &AnsiStringVDMEnv,
      
1219.                                                   &UnicodeStringVDMEnv)) {
      
1220.                         return FALSE;
      
1221.                         }
      
1222. 
      
1223. RetrySepWow:
      
1224.                     VdmBinaryType = dwCreationFlags & CREATE_SEPARATE_WOW_VDM
      
1225.                                      ? BINARY_TYPE_SEPWOW : BINARY_TYPE_WIN16;
      
1226. 
      
1227.                     if (!BaseCheckVDM(VdmBinaryType,
      
1228.                                       lpApplicationName,
      
1229.                                       lpCommandLine,
      
1230.                                       lpCurrentDirectory,
      
1231.                                       &AnsiStringVDMEnv,
      
1232.                                       &m,
      
1233.                                       &iTask,
      
1234.                                       dwCreationFlags,
      
1235.                                       &StartupInfo
      
1236.                                       ))
      
1237.                        {
      
1238.                         //
      
1239.                         // If we failed with access denied, caller may not
      
1240.                         // be allowed allowed to access the shared wow's
      
1241.                         // desktop, so retry as a separate wow
      
1242.                         //
      
1243.                         if (VdmBinaryType == BINARY_TYPE_WIN16 &&
      
1244.                             GetLastError() == ERROR_ACCESS_DENIED)
      
1245.                           {
      
1246.                            dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
      
1247.                            }
      
1248.                         else {
      
1249.                             return FALSE;
      
1250.                             }
      
1251.                         goto RetrySepWow;
      
1252.                         }
      
1253. 
      
1254.                     // Check the return value from the server
      
1255.                     switch (b->VDMState & VDM_STATE_MASK){
      
1256.                         case VDM_NOT_PRESENT:
      
1257.                             // mark this so the server can undo
      
1258.                             // creation if something goes wrong.
      
1259.                             // We marked it "partitially created" because
      
1260.                             // the NTVDM has yet not been fully created.
      
1261.                             // a call to UpdateVdmEntry to update
      
1262.                             // process handle will signal the NTVDM
      
1263.                             // process completed creation
      
1264. 
      
1265.                             VDMCreationState = VDM_PARTIALLY_CREATED;
      
1266. 
      
1267.                             // jarbats: 1/8/2001
      
1268.                             // Tell BaseGetVdmConfigInfo to create
      
1269.                             // vdm commandline for meow
      
1270.                             //
      
1271. 
      
1272.                             if (bMeowBinary)
      
1273.                                {
      
1274.                                VdmReserve = 1;
      
1275.                                }
      
1276. 
      
1277.                             if (!BaseGetVdmConfigInfo(
      
1278.                                     lpCommandLine,
      
1279.                                     iTask,
      
1280.                                     VdmBinaryType,
      
1281.                                     &VdmNameString,
      
1282.                                     &VdmReserve
      
1283.                                     )) {
      
1284.                                 BaseSetLastNTError(Status);
      
1285.                                 return FALSE;
      
1286.                                 }
      
1287. 
      
1288.                             lpCommandLine = VdmNameString.Buffer;
      
1289.                             lpApplicationName = NULL;
      
1290. 
      
1291. 
      
1292.                             //
      
1293.                             // Wow must have a hidden console
      
1294.                             // Throw away DETACHED_PROCESS flag which isn't
      
1295.                             // meaningful for Win16 apps.
      
1296.                             //
      
1297. 
      
1298.                             dwCreationFlags |= CREATE_NO_WINDOW;
      
1299.                             dwCreationFlags &= ~(CREATE_NEW_CONSOLE | DETACHED_PROCESS);
      
1300. 
      
1301. 
      
1302.                             //
      
1303.                             // We're starting a WOW VDM, turn on feedback unless
      
1304.                             // the creator passed STARTF_FORCEOFFFEEDBACK.
      
1305.                             //
      
1306. 
      
1307.                             StartupInfo.dwFlags |= STARTF_FORCEONFEEDBACK;
      
1308. 
      
1309.                             break;
      
1310. 
      
1311.                         case VDM_PRESENT_NOT_READY:
      
1312.                             SetLastError (ERROR_NOT_READY);
      
1313.                             return FALSE;
      
1314. 
      
1315.                         case VDM_PRESENT_AND_READY:
      
1316.                             VDMCreationState = VDM_BEING_REUSED;
      
1317.                             VdmWaitHandle = b->WaitObjectForParent;
      
1318.                             break;
      
1319.                         }
      
1320. 
      
1321.                     VdmReserve--;               // we reserve from addr 1
      
1322.                     if(VdmWaitHandle)
      
1323.                         goto VdmExists;
      
1324.                     else {
      
1325.                         bInheritHandles = FALSE;
      
1326.                         // replace the environment with ours
      
1327.                         if (lpEnvironment &&
      
1328.                             !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT)) {
      
1329.                             RtlDestroyEnvironment(lpEnvironment);
      
1330.                             }
      
1331.                         lpEnvironment = UnicodeStringVDMEnv.Buffer;
      
1332.                         bVdmRetry = TRUE;
      
1333.                         goto VdmRetry;
      
1334.                         }
      
1335. 
      
1336.                 case STATUS_FILE_IS_OFFLINE:
      
1337.                     SetLastError(ERROR_FILE_OFFLINE);
      
1338.                     break;
      
1339. 
      
1340.                 default :
      
1341.                     SetLastError(ERROR_BAD_EXE_FORMAT);
      
1342.                     return FALSE;
      
1343.             }
      
1344.         }
      
1345. 
      
1346.         //
      
1347.         // Make sure only WOW apps can have the CREATE_SEPARATE_WOW_VDM flag.
      
1348.         //
      
1349. 
      
1350.         if (!IsWowBinary && (dwCreationFlags & CREATE_SEPARATE_WOW_VDM)) {
      
1351.             dwCreationFlags &= ~CREATE_SEPARATE_WOW_VDM;
      
1352.         }
      
1353. 
      
1354.         //
      
1355.         // Query the section to determine the stack parameters and
      
1356.         // image entrypoint.
      
1357.         //
      
1358. 
      
1359.         Status = NtQuerySection(
      
1360.                     SectionHandle,
      
1361.                     SectionImageInformation,
      
1362.                     &ImageInformation,
      
1363.                     sizeof( ImageInformation ),
      
1364.                     NULL
      
1365.                     );
      
1366. 
      
1367.         if (!NT_SUCCESS( Status )) {
      
1368.             BaseSetLastNTError(Status);
      
1369.             return FALSE;
      
1370.             }
      
1371. 
      
1372.         if (ImageInformation.ImageCharacteristics & IMAGE_FILE_DLL) {
      
1373.             SetLastError(ERROR_BAD_EXE_FORMAT);
      
1374.             return FALSE;
      
1375.             }
      
1376. 
      
1377.         ImageFileDebuggerCommand[ 0 ] = UNICODE_NULL;
      
1378.         if (!(dwCreationFlags & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS)) ||
      
1379.             NtCurrentPeb()->ReadImageFileExecOptions
      
1380.            ) {
      
1381.             LdrQueryImageFileExecutionOptions( &PathName,
      
1382.                                                L"Debugger",
      
1383.                                                REG_SZ,
      
1384.                                                ImageFileDebuggerCommand,
      
1385.                                                sizeof( ImageFileDebuggerCommand ),
      
1386.                                                NULL
      
1387.                                              );
      
1388.             }
      
1389. 
      
1390. 
      
1391.         if ((ImageInformation.Machine < USER_SHARED_DATA->ImageNumberLow) ||
      
1392.             (ImageInformation.Machine > USER_SHARED_DATA->ImageNumberHigh)) {
      
1393. #if defined(_WIN64) || defined(BUILD_WOW6432)
      
1394.             if (ImageInformation.Machine == IMAGE_FILE_MACHINE_I386) {
      
1395.                // Fall through since this is a valid machine type.
      
1396.                 }
      
1397.              else
      
1398. #endif
      
1399.                 {
      
1400.                 ULONG_PTR ErrorParameters[2];
      
1401.                 ULONG ErrorResponse;
      
1402. 
      
1403. #if defined(_WIN64) || defined(BUILD_WOW6432)
      
1404. RaiseInvalidWin32Error:
      
1405. #endif
      
1406.                 ErrorResponse = ResponseOk;
      
1407.                 ErrorParameters[0] = (ULONG_PTR)&PathName;
      
1408. 
      
1409.                 NtRaiseHardError( STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE,
      
1410.                                   1,
      
1411.                                   1,
      
1412.                                   ErrorParameters,
      
1413.                                   OptionOk,
      
1414.                                   &ErrorResponse
      
1415.                                 );
      
1416.                 if ( NtCurrentPeb()->ImageSubsystemMajorVersion <= 3 ) {
      
1417.                     SetLastError(ERROR_BAD_EXE_FORMAT);
      
1418.                     }
      
1419.                 else {
      
1420.                     SetLastError(ERROR_EXE_MACHINE_TYPE_MISMATCH);
      
1421.                     }
      
1422.                 return FALSE;
      
1423.                 }
      
1424.             }
      
1425. 
      
1426.         if ( ImageInformation.SubSystemType != IMAGE_SUBSYSTEM_WINDOWS_GUI &&
      
1427.              ImageInformation.SubSystemType != IMAGE_SUBSYSTEM_WINDOWS_CUI ) {
      
1428. 
      
1429.             // POSIX exe
      
1430. 
      
1431.             NtClose(SectionHandle);
      
1432.             SectionHandle = NULL;
      
1433. 
      
1434.             if ( ImageInformation.SubSystemType == IMAGE_SUBSYSTEM_POSIX_CUI ) {
      
1435. 
      
1436.                 if ( !BuildSubSysCommandLine( L"POSIX /P ",
      
1437.                                               lpApplicationName,
      
1438.                                               lpCommandLine,
      
1439.                                               &SubSysCommandLine
      
1440.                                             ) ) {
      
1441.                     return FALSE;
      
1442.                 }
      
1443. 
      
1444.                 lpCommandLine = SubSysCommandLine.Buffer;
      
1445. 
      
1446.                 lpApplicationName = NULL;
      
1447.                 bVdmRetry = TRUE;
      
1448.                 goto VdmRetry;
      
1449.                 }
      
1450.             else {
      
1451.                 SetLastError(ERROR_CHILD_NOT_COMPLETE);
      
1452.                 return FALSE;
      
1453.                 }
      
1454.             }
      
1455.         else {
      
1456.             if (!BasepIsImageVersionOk( ImageInformation.SubSystemMajorVersion,
      
1457.                                         ImageInformation.SubSystemMinorVersion) ) {
      
1458.                 SetLastError(ERROR_BAD_EXE_FORMAT);
      
1459.                 return FALSE;
      
1460.                 }
      
1461.             }
      
1462. 
      
1463.         if (ImageFileDebuggerCommand[ 0 ] != UNICODE_NULL) {
      
1464.             SIZE_T n;
      
1465. 
      
1466.             n = wcslen( lpCommandLine );
      
1467.             if (n == 0) {
      
1468.                 lpCommandLine = (LPWSTR)lpApplicationName;
      
1469.                 n = wcslen( lpCommandLine );
      
1470.                 }
      
1471. 
      
1472.             n += wcslen( ImageFileDebuggerCommand ) + 1 + 2;
      
1473.             n *= sizeof( WCHAR );
      
1474. 
      
1475.             SubSysCommandLine.Buffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( TMP_TAG ), n );
      
1476.             SubSysCommandLine.Length = 0;
      
1477.             SubSysCommandLine.MaximumLength = (USHORT)n;
      
1478.             RtlAppendUnicodeToString( &SubSysCommandLine, ImageFileDebuggerCommand );
      
1479.             RtlAppendUnicodeToString( &SubSysCommandLine, L" " );
      
1480.             RtlAppendUnicodeToString( &SubSysCommandLine, lpCommandLine );
      
1481. #if DBG
      
1482.             DbgPrint( "BASE: Calling debugger with '%wZ'\n", &SubSysCommandLine );
      
1483. #endif
      
1484.             lpCommandLine = SubSysCommandLine.Buffer;
      
1485.             lpApplicationName = NULL;
      
1486.             NtClose(SectionHandle);
      
1487.             SectionHandle = NULL;
      
1488.             RtlFreeHeap(RtlProcessHeap(), 0, NameBuffer);
      
1489.             NameBuffer = NULL;
      
1490.             RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
      
1491.             FreeBuffer = NULL;
      
1492.             goto VdmRetry;
      
1493.             }
      
1494. 
      
1495.         //
      
1496.         // Create the process object
      
1497.         //
      
1498. 
      
1499.         pObja = BaseFormatObjectAttributes(&Obja,lpProcessAttributes,NULL);
      
1500. 
      
1501.         Flags = 0;
      
1502.         if (dwCreationFlags & CREATE_BREAKAWAY_FROM_JOB ) {
      
1503.             Flags |= PROCESS_CREATE_FLAGS_BREAKAWAY;
      
1504.         }
      
1505. 
      
1506.         if ( dwCreationFlags & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS) ) {
      
1507.             Status = DbgUiConnectToDbg();
      
1508.             if ( !NT_SUCCESS(Status) ) {
      
1509.                 BaseSetLastNTError(Status);
      
1510.                 return FALSE;
      
1511.             }
      
1512.             DebugPortHandle = DbgUiGetThreadDebugObject ();
      
1513.             if (dwCreationFlags & DEBUG_ONLY_THIS_PROCESS) {
      
1514.                 Flags |= PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT;
      
1515.             }
      
1516.         }
      
1517. 
      
1518.         if (bInheritHandles) {
      
1519.             Flags |= PROCESS_CREATE_FLAGS_INHERIT_HANDLES;
      
1520.         }
      
1521. 
      
1522.         if (((ImageInformation.LoaderFlags & IMAGE_LOADER_FLAGS_COMPLUS) != 0)) {
      
1523. 
      
1524. #if defined(_WIN64) || defined(BUILD_WOW6432)
      
1525. 
      
1526.             //
      
1527.             // Check if this is a 32-bit IL_ONLY COM+ image that needs to run natively
      
1528.             // on Win64.
      
1529.             //
      
1530. 
      
1531.             if ( ImageInformation.Machine == IMAGE_FILE_MACHINE_I386 ) {
      
1532. 
      
1533.                 Status = BasepIsComplusILImage(
      
1534.                                               SectionHandle,
      
1535.                                               &ImageInformation,
      
1536.                                               &ComPlusILImage
      
1537.                                               );
      
1538. 
      
1539.                 if ((NT_SUCCESS (Status)) && (ComPlusILImage != FALSE)) {
      
1540.                     Flags |= PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE;
      
1541.                 }
      
1542.             }
      
1543. 
      
1544. #endif
      
1545.         }
      
1546.             
      
1547.         //
      
1548.         // This is temporary till we get Shim dlls support for native Win64 applications.
      
1549.         //
      
1550. 
      
1551.         if (ImageInformation.Machine != IMAGE_FILE_MACHINE_I386) {
      
1552.             pAppCompatDataTemp = NULL;
      
1553.         } else {
      
1554.             pAppCompatDataTemp = pAppCompatData;
      
1555.         }
      
1556. 
      
1557.         Status = NtCreateProcessEx(
      
1558.                     &ProcessHandle,
      
1559.                     PROCESS_ALL_ACCESS,
      
1560.                     pObja,
      
1561.                     NtCurrentProcess(),
      
1562.                     Flags,
      
1563.                     SectionHandle,
      
1564.                     DebugPortHandle,
      
1565.                     NULL,
      
1566.                     dwJobMemberLevel         // Job member level
      
1567.                     );
      
1568.         if ( !NT_SUCCESS(Status) ) {
      
1569.             BaseSetLastNTError(Status);
      
1570.             return FALSE;
      
1571.         }
      
1572. 
      
1573.         //
      
1574.         // NtCreateProcess will set to normal OR inherit if parent is IDLE or Below
      
1575.         // only override if a mask is given during the create.
      
1576.         //
      
1577. 
      
1578.         if ( PriClass.PriorityClass != PROCESS_PRIORITY_CLASS_UNKNOWN ) {
      
1579.             State = NULL;
      
1580.             if ( PriClass.PriorityClass ==  PROCESS_PRIORITY_CLASS_REALTIME ) {
      
1581.                 State = BasepIsRealtimeAllowed(TRUE);
      
1582.                 }
      
1583.             Status = NtSetInformationProcess(
      
1584.                         ProcessHandle,
      
1585.                         ProcessPriorityClass,
      
1586.                         (PVOID)&PriClass,
      
1587.                         sizeof(PriClass)
      
1588.                         );
      
1589.             if ( State ) {
      
1590.                 BasepReleasePrivilege( State );
      
1591.                 }
      
1592. 
      
1593.             if ( !NT_SUCCESS(Status) ) {
      
1594.                 BaseSetLastNTError(Status);
      
1595.                 return FALSE;
      
1596.                 }
      
1597.             }
      
1598. 
      
1599.         if (dwCreationFlags & CREATE_DEFAULT_ERROR_MODE) {
      
1600.             UINT NewMode;
      
1601.             NewMode = SEM_FAILCRITICALERRORS;
      
1602.             NtSetInformationProcess(
      
1603.                 ProcessHandle,
      
1604.                 ProcessDefaultHardErrorMode,
      
1605.                 &NewMode,
      
1606.                 sizeof(NewMode)
      
1607.                 );
      
1608.             }
      
1609. 
      
1610.         //
      
1611.         // If the process is being created for a VDM call the server with
      
1612.         // process handle.
      
1613.         //
      
1614. 
      
1615.         if (VdmBinaryType) {
      
1616.             VdmWaitHandle = ProcessHandle;
      
1617.             if (!BaseUpdateVDMEntry(UPDATE_VDM_PROCESS_HANDLE,
      
1618.                                     &VdmWaitHandle,
      
1619.                                     iTask,
      
1620.                                     VdmBinaryType
      
1621.                                     ))
      
1622.                 {
      
1623.                 //make sure we don't close the handle twice --
      
1624.                 //(VdmWaitHandle == ProcessHandle) if we don't do this.
      
1625.                 VdmWaitHandle = NULL;
      
1626.                 return FALSE;
      
1627.                 }
      
1628. 
      
1629.             //
      
1630.             // For Sep wow the VdmWaitHandle = NULL (there is none!)
      
1631.             //
      
1632. 
      
1633.             VDMCreationState |= VDM_FULLY_CREATED;
      
1634.             }
      
1635. 
      
1636. 
      
1637. #if defined(i386)
      
1638.         //
      
1639.         // Reserve memory in the new process' address space if necessary
      
1640.         // (for vdms). This is required only for x86 system.
      
1641.         //
      
1642. 
      
1643.     if ( VdmReserve ) {
      
1644.             BigVdmReserve = VdmReserve;
      
1645.             Status = NtAllocateVirtualMemory(
      
1646.                         ProcessHandle,
      
1647.                         &BaseAddress,
      
1648.                         0L,
      
1649.                         &BigVdmReserve,
      
1650.                         MEM_RESERVE,
      
1651.                         PAGE_EXECUTE_READWRITE
      
1652.                         );
      
1653.             if ( !NT_SUCCESS(Status) ){
      
1654.                 BaseSetLastNTError(Status);
      
1655.                 return FALSE;
      
1656.             }
      
1657.     }
      
1658. #endif
      
1659. 
      
1660.         //
      
1661.         // Abuse the StaticSize fields temporarily.
      
1662.         // They are somewhat private, but we are using them for temporary space, sort of.
      
1663.         // These are the right values for them, but we need to call the proper initialization function,
      
1664.         // which will store the values a second time (possibly optimized away).
      
1665.         //
      
1666.         SxsWin32ManifestPathBuffer.ByteBuffer.StaticSize = SxsWin32ExePath.Length + sizeof(SXS_MANIFEST_SUFFIX);
      
1667.         SxsWin32PolicyPathBuffer.ByteBuffer.StaticSize = SxsWin32ExePath.Length + sizeof(SXS_POLICY_SUFFIX);
      
1668.         SxsWin32AssemblyDirectoryBuffer.ByteBuffer.StaticSize = SxsWin32ExePath.Length + sizeof(WCHAR); // Win32AssemblyDirectory overestimate
      
1669.         SxsNtManifestPathBuffer.ByteBuffer.StaticSize = SxsNtExePath.Length + sizeof(SXS_MANIFEST_SUFFIX);
      
1670.         SxsNtPolicyPathBuffer.ByteBuffer.StaticSize = SxsNtExePath.Length + sizeof(SXS_POLICY_SUFFIX);
      
1671.         //
      
1672.         // now add them up as BYTE sizes
      
1673.         //
      
1674.         SxsConglomeratedBufferSizeBytes = 0;
      
1675.         for (sxsi = 0 ; sxsi != RTL_NUMBER_OF(SxsStringBuffers) ; ++sxsi) {
      
1676.             SxsConglomeratedBufferSizeBytes += SxsStringBuffers[sxsi]->ByteBuffer.StaticSize;
      
1677.         }
      
1678. #if DBG
      
1679.         DbgPrintEx(
      
1680.             DPFLTR_SXS_ID,
      
1681.             DPFLTR_INFO_LEVEL,
      
1682.             "SXS: SxsConglomeratedBufferSizeBytes:%Id\n",
      
1683.             SxsConglomeratedBufferSizeBytes
      
1684.             );
      
1685. #endif
      
1686.         //
      
1687.         // one honking heap allocation
      
1688.         //
      
1689.         SxsConglomeratedByteBuffer = (PBYTE)RtlAllocateHeap(RtlProcessHeap(), 0, SxsConglomeratedBufferSizeBytes);
      
1690.         if (SxsConglomeratedByteBuffer == NULL) {
      
1691.             BaseSetLastNTError(STATUS_NO_MEMORY);
      
1692.             return FALSE;
      
1693.         }
      
1694.         //
      
1695.         // now dole out pieces, calling the proper initialization function
      
1696.         //
      
1697.         for (sxsi= 0 ; sxsi != RTL_NUMBER_OF(SxsStringBuffers) ; ++sxsi) {
      
1698.             RtlInitUnicodeStringBuffer(
      
1699.                 SxsStringBuffers[sxsi],
      
1700.                 (sxsi != 0) ? SxsStringBuffers[sxsi - 1]->ByteBuffer.Buffer + SxsStringBuffers[sxsi- 1]->ByteBuffer.StaticSize
      
1701.                          : SxsConglomeratedByteBuffer,
      
1702.                 SxsStringBuffers[sxsi]->ByteBuffer.StaticSize
      
1703.                 );
      
1704.         }
      
1705. 
      
1706.         SxsExeHandles.Process = ProcessHandle;
      
1707.         SxsExeHandles.File = FileHandle;
      
1708.          // The 1 bit here means something different than in the loader.
      
1709.         ASSERT((((ULONG_PTR)SectionHandle) & (ULONG_PTR)1) == 0);
      
1710.         SxsExeHandles.Section = SectionHandle;
      
1711. 
      
1712.         // if we have an override stream, use it
      
1713.         if (NULL != pAppCompatSxsData) {
      
1714.             AppCompatSxsManifest.Name    = SxsWin32ExePath;     // unicode string
      
1715.             AppCompatSxsManifest.Address = pAppCompatSxsData;   // pointer to unicode manifest
      
1716.             AppCompatSxsManifest.Size    = cbAppCompatSxsData;  // byte count
      
1717.         }
      
1718. 
      
1719.         Status = BasepSxsCreateProcessCsrMessage(
      
1720.             (NULL != pAppCompatSxsData) ? &AppCompatSxsManifest : NULL, // override manifest (appcompat hook)
      
1721.             NULL, // override policy (appcompat hook)
      
1722.             &SxsManifestPathPair,
      
1723.             &SxsManifestFileHandles,
      
1724.             &SxsExePathPair,
      
1725.             &SxsExeHandles,
      
1726.             &SxsPolicyPathPair,
      
1727.             &SxsPolicyHandles,
      
1728.             &SxsWin32AssemblyDirectoryBuffer,
      
1729.             &a->Sxs
      
1730.             );
      
1731. #if DBG
      
1732.         // verify the buffer size calculation
      
1733.         for (sxsi = 0 ; sxsi != RTL_NUMBER_OF(SxsStringBuffers) ; ++sxsi)
      
1734.         {
      
1735.             if (SxsStringBuffers[sxsi]->ByteBuffer.Buffer != SxsStringBuffers[sxsi]->ByteBuffer.StaticBuffer)
      
1736.             {
      
1737.                 DbgPrintEx(
      
1738.                     DPFLTR_SXS_ID,
      
1739.                     DPFLTR_WARNING_LEVEL,
      
1740.                     "SXS: SxsStringBuffers[%lu]'s StaticSize was computed too small (%Id, %Id)\n",
      
1741.                     sxsi,
      
1742.                     SxsStringBuffers[sxsi]->ByteBuffer.StaticSize,
      
1743.                     SxsStringBuffers[sxsi]->ByteBuffer.Size
      
1744.                     );
      
1745.             }
      
1746.         }
      
1747. #endif
      
1748.         if ( !NT_SUCCESS( Status ) ) {
      
1749.             BaseSetLastNTError(Status);
      
1750.             return FALSE;
      
1751.             }
      
1752. 
      
1753.         //
      
1754.         // Determine the location of the
      
1755.         // processes PEB.
      
1756.         //
      
1757. 
      
1758.         Status = NtQueryInformationProcess(
      
1759.                     ProcessHandle,
      
1760.                     ProcessBasicInformation,
      
1761.                     &ProcessInfo,
      
1762.                     sizeof( ProcessInfo ),
      
1763.                     NULL
      
1764.                     );
      
1765.         if ( !NT_SUCCESS( Status ) ) {
      
1766.             BaseSetLastNTError(Status);
      
1767.             return FALSE;
      
1768.             }
      
1769. 
      
1770.         Peb = ProcessInfo.PebBaseAddress;
      
1771. 
      
1772.         //
      
1773.         // Push the parameters into the address space of the new process
      
1774.         //
      
1775. 
      
1776.         if ( ARGUMENT_PRESENT(lpCurrentDirectory) ) {
      
1777.             CurdirBuffer = RtlAllocateHeap( RtlProcessHeap(),
      
1778.                                             MAKE_TAG( TMP_TAG ),
      
1779.                                             (MAX_PATH + 1) * sizeof( WCHAR ) );
      
1780.             if ( !CurdirBuffer ) {
      
1781.                 BaseSetLastNTError(STATUS_NO_MEMORY);
      
1782.                 return FALSE;
      
1783.                 }
      
1784.             CurdirLength2 = GetFullPathNameW(
      
1785.                                 lpCurrentDirectory,
      
1786.                                 MAX_PATH,
      
1787.                                 CurdirBuffer,
      
1788.                                 &CurdirFilePart
      
1789.                                 );
      
1790.             if ( CurdirLength2 > MAX_PATH ) {
      
1791.                 SetLastError(ERROR_DIRECTORY);
      
1792.                 return FALSE;
      
1793.                 }
      
1794. 
      
1795.             //
      
1796.             // now make sure the directory exists
      
1797.             //
      
1798. 
      
1799.             CurdirLength = GetFileAttributesW(CurdirBuffer);
      
1800.             if ( (CurdirLength == 0xffffffff) ||
      
1801.                  !(CurdirLength & FILE_ATTRIBUTE_DIRECTORY) ) {
      
1802.                 SetLastError(ERROR_DIRECTORY);
      
1803.                 return FALSE;
      
1804.                 }
      
1805.             }
      
1806. 
      
1807. 
      
1808.         if ( QuoteInsert || QuoteCmdLine) {
      
1809.             QuotedBuffer = RtlAllocateHeap(RtlProcessHeap(),0,wcslen(lpCommandLine)*2+6);
      
1810. 
      
1811.             if ( QuotedBuffer ) {
      
1812.                 wcscpy(QuotedBuffer,L""");
      
1813. 
      
1814.                 if ( QuoteInsert ) {
      
1815.                     TempChar = *TempNull;
      
1816.                     *TempNull = UNICODE_NULL;
      
1817.                     }
      
1818. 
      
1819.                 wcscat(QuotedBuffer,lpCommandLine);
      
1820.                 wcscat(QuotedBuffer,L""");
      
1821. 
      
1822.                 if ( QuoteInsert ) {
      
1823.                     *TempNull = TempChar;
      
1824.                     wcscat(QuotedBuffer,TempNull);
      
1825.                     }
      
1826. 
      
1827.                 }
      
1828.             else {
      
1829.                 if ( QuoteInsert ) {
      
1830.                     QuoteInsert = FALSE;
      
1831.                     }
      
1832.                 if ( QuoteCmdLine ) {
      
1833.                     QuoteCmdLine = FALSE;
      
1834.                     }
      
1835.                 }
      
1836.             }
      
1837. 
      
1838. 
      
1839.         // If we found a manifest, we want to push that fact to the new process.
      
1840.         if (a->Sxs.Flags & BASE_MSG_SXS_MANIFEST_PRESENT)
      
1841.             dwBasePushProcessParametersFlags |= BASE_PUSH_PROCESS_PARAMETERS_FLAG_APP_MANIFEST_PRESENT;
      
1842. 
      
1843.         if (!BasePushProcessParameters(
      
1844.                 dwBasePushProcessParametersFlags,
      
1845.                 ProcessHandle,
      
1846.                 Peb,
      
1847.                 lpApplicationName,
      
1848.                 CurdirBuffer,
      
1849.                 QuoteInsert || QuoteCmdLine ? QuotedBuffer : lpCommandLine,
      
1850.                 lpEnvironment,
      
1851.                 &StartupInfo,
      
1852.                 dwCreationFlags | dwNoWindow,
      
1853.                 bInheritHandles,
      
1854.                 IsWowBinary ? IMAGE_SUBSYSTEM_WINDOWS_GUI : 0,
      
1855.                 pAppCompatDataTemp,
      
1856.                 cbAppCompatData
      
1857.                 ) ) {
      
1858.             return FALSE;
      
1859.             }
      
1860. 
      
1861. 
      
1862.         RtlFreeUnicodeString(&VdmNameString);
      
1863.         VdmNameString.Buffer = NULL;
      
1864. 
      
1865.         //
      
1866.         // Stuff in the standard handles if needed
      
1867.         //
      
1868.         if (!VdmBinaryType &&
      
1869.             !bInheritHandles &&
      
1870.             !(StartupInfo.dwFlags & STARTF_USESTDHANDLES) &&
      
1871.             !(dwCreationFlags & (DETACHED_PROCESS | CREATE_NEW_CONSOLE | CREATE_NO_WINDOW)) &&
      
1872.             ImageInformation.SubSystemType == IMAGE_SUBSYSTEM_WINDOWS_CUI
      
1873.            ) {
      
1874.             PRTL_USER_PROCESS_PARAMETERS ParametersInNewProcess;
      
1875. 
      
1876.             Status = NtReadVirtualMemory( ProcessHandle,
      
1877.                                           &Peb->ProcessParameters,
      
1878.                                           &ParametersInNewProcess,
      
1879.                                           sizeof( ParametersInNewProcess ),
      
1880.                                           NULL
      
1881.                                         );
      
1882.             if (NT_SUCCESS( Status )) {
      
1883.                 if (!CONSOLE_HANDLE( NtCurrentPeb()->ProcessParameters->StandardInput )) {
      
1884.                     StuffStdHandle( ProcessHandle,
      
1885.                                     NtCurrentPeb()->ProcessParameters->StandardInput,
      
1886.                                     &ParametersInNewProcess->StandardInput
      
1887.                                   );
      
1888.                     }
      
1889.                 if (!CONSOLE_HANDLE( NtCurrentPeb()->ProcessParameters->StandardOutput )) {
      
1890.                     StuffStdHandle( ProcessHandle,
      
1891.                                     NtCurrentPeb()->ProcessParameters->StandardOutput,
      
1892.                                     &ParametersInNewProcess->StandardOutput
      
1893.                                   );
      
1894.                     }
      
1895.                 if (!CONSOLE_HANDLE( NtCurrentPeb()->ProcessParameters->StandardError )) {
      
1896.                     StuffStdHandle( ProcessHandle,
      
1897.                                     NtCurrentPeb()->ProcessParameters->StandardError,
      
1898.                                     &ParametersInNewProcess->StandardError
      
1899.                                   );
      
1900.                     }
      
1901.                 }
      
1902.             }
      
1903. 
      
1904.         //
      
1905.         // Create the thread...
      
1906.         //
      
1907. 
      
1908.         //
      
1909.         // Allocate a stack for this thread in the address space of the target
      
1910.         // process.
      
1911.         //
      
1912. 
      
1913.         StackStatus = BaseCreateStack(
      
1914.                         ProcessHandle,
      
1915.                         ImageInformation.CommittedStackSize,
      
1916.                         (ImageInformation.MaximumStackSize < 256*1024) ? 256*1024 : ImageInformation.MaximumStackSize,
      
1917.                         &InitialTeb
      
1918.                         );
      
1919. 
      
1920.         if ( !NT_SUCCESS(StackStatus) ) {
      
1921.             BaseSetLastNTError(StackStatus);
      
1922.             return FALSE;
      
1923.             }
      
1924. 
      
1925. 
      
1926.         //
      
1927.         // Create an initial context for the new thread.
      
1928.         //
      
1929. 
      
1930.         BaseInitializeContext(
      
1931.             &ThreadContext,
      
1932.             Peb,
      
1933.             ImageInformation.TransferAddress,
      
1934.             InitialTeb.StackBase,
      
1935.             BaseContextTypeProcess
      
1936.             );
      
1937. 
      
1938. 
      
1939.         //
      
1940.         // Create the actual thread object
      
1941.         //
      
1942. 
      
1943.         pObja = BaseFormatObjectAttributes(&Obja,lpThreadAttributes,NULL);
      
1944. 
      
1945.         Status = NtCreateThread(
      
1946.                     &ThreadHandle,
      
1947.                     THREAD_ALL_ACCESS,
      
1948.                     pObja,
      
1949.                     ProcessHandle,
      
1950.                     &ClientId,
      
1951.                     &ThreadContext,
      
1952.                     &InitialTeb,
      
1953.                     TRUE
      
1954.                     );
      
1955. 
      
1956.         if (!NT_SUCCESS(Status) ) {
      
1957.             BaseSetLastNTError(Status);
      
1958.             return FALSE;
      
1959.             }
      
1960. 
      
1961.         a->Peb = (ULONGLONG) Peb;
      
1962. 
      
1963.         //
      
1964.         // From here on out, do not modify the address space of the
      
1965.         // new process.  WOW64's implementation of NtCreateThread()
      
1966.         // reshuffles the new process' address space if the current
      
1967.         // process is 32-bit and the new process is 64-bit.
      
1968.         //
      
1969. #if DBG
      
1970.         Peb = NULL;
      
1971. #endif
      
1972. 
      
1973. #if defined(WX86)
      
1974. 
      
1975.         //
      
1976.         // if this is a Wx86 Process, setup for a Wx86 emulated Thread
      
1977.         //
      
1978. 
      
1979.         if (Wx86Info) {
      
1980. 
      
1981.             //
      
1982.             // create a WX86Tib and initialize it's Teb->Vdm.
      
1983.             //
      
1984.             Status = BaseCreateWx86Tib(ProcessHandle,
      
1985.                                        ThreadHandle,
      
1986.                                        (ULONG)((ULONG_PTR)ImageInformation.TransferAddress),
      
1987.                                        (ULONG)ImageInformation.CommittedStackSize,
      
1988.                                        (ULONG)ImageInformation.MaximumStackSize,
      
1989.                                        TRUE
      
1990.                                        );
      
1991. 
      
1992.             if (!NT_SUCCESS(Status)) {
      
1993.                 BaseSetLastNTError(Status);
      
1994.                 return( FALSE );
      
1995.                 }
      
1996. 
      
1997. 
      
1998.             //
      
1999.             // Mark Process as WX86
      
2000.             //
      
2001.             Status = NtSetInformationProcess (ProcessHandle,
      
2002.                                               ProcessWx86Information,
      
2003.                                               &Wx86Info,
      
2004.                                               sizeof(Wx86Info)
      
2005.                                               );
      
2006. 
      
2007.             if (!NT_SUCCESS(Status)) {
      
2008.                 BaseSetLastNTError(Status);
      
2009.                 return( FALSE );
      
2010.                 }
      
2011.             }
      
2012. #endif
      
2013. 
      
2014. 
      
2015.         //
      
2016.         // Call the Windows server to let it know about the
      
2017.         // process.
      
2018.         //
      
2019. 
      
2020.         a->ProcessHandle = ProcessHandle;
      
2021.         a->ThreadHandle = ThreadHandle;
      
2022.         a->ClientId = ClientId;
      
2023. 
      
2024.         switch (ImageInformation.Machine) {
      
2025.         case IMAGE_FILE_MACHINE_I386:
      
2026. #if defined(_WIN64) || defined(BUILD_WOW6432)
      
2027.             a->ProcessorArchitecture = PROCESSOR_ARCHITECTURE_IA32_ON_WIN64;
      
2028. #else
      
2029.             a->ProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
      
2030. #endif
      
2031.             break;
      
2032. 
      
2033.         case IMAGE_FILE_MACHINE_IA64:
      
2034.             a->ProcessorArchitecture = PROCESSOR_ARCHITECTURE_IA64;
      
2035.             break;
      
2036. 
      
2037.         case IMAGE_FILE_MACHINE_AMD64:
      
2038.             a->ProcessorArchitecture = PROCESSOR_ARCHITECTURE_AMD64;
      
2039.             break;
      
2040. 
      
2041.         default:
      
2042.             DbgPrint("kernel32: No mapping for ImageInformation.Machine == %04x\n", ImageInformation.Machine);
      
2043.             a->ProcessorArchitecture = PROCESSOR_ARCHITECTURE_UNKNOWN;
      
2044.             break;
      
2045.         }
      
2046. 
      
2047.         //
      
2048.         // remove debug flags now its not being done by CSR
      
2049.         //
      
2050.         a->CreationFlags = dwCreationFlags & ~ (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS);
      
2051.         a->DebuggerClientId.UniqueProcess = NULL;
      
2052.         a->DebuggerClientId.UniqueThread = NULL;
      
2053. 
      
2054. 
      
2055.         //
      
2056.         // Set the 2 bit if a gui app is starting. The window manager needs to
      
2057.         // know this so it can synchronize the startup of this app
      
2058.         // (WaitForInputIdle api). This info is passed using the process
      
2059.         // handle tag bits.  The 1 bit asks the window manager to turn on
      
2060.         // or turn off the application start cursor (hourglass/pointer).
      
2061.         //
      
2062.         // When starting a WOW process, lie and tell UserSrv NTVDM.EXE is a GUI
      
2063.         // process.  We also turn on bit 0x8 so that UserSrv can ignore the
      
2064.         // UserNotifyConsoleApplication call made by the console during startup.
      
2065.         //
      
2066. 
      
2067.         if ( ImageInformation.SubSystemType == IMAGE_SUBSYSTEM_WINDOWS_GUI ||
      
2068.              IsWowBinary ) {
      
2069. 
      
2070.             a->ProcessHandle = (HANDLE)((ULONG_PTR)a->ProcessHandle | 2);
      
2071. 
      
2072.             //
      
2073.             // If the creating process is a GUI app, turn on the app. start cursor
      
2074.             // by default.  This can be overridden by STARTF_FORCEOFFFEEDBACK.
      
2075.             //
      
2076. 
      
2077.             NtHeaders = RtlImageNtHeader((PVOID)GetModuleHandle(NULL));
      
2078.             if ( NtHeaders
      
2079.                  && (NtHeaders->OptionalHeader.Subsystem
      
2080.                      == IMAGE_SUBSYSTEM_WINDOWS_GUI ) ) {
      
2081.                 a->ProcessHandle = (HANDLE)((ULONG_PTR)a->ProcessHandle | 1);
      
2082.                 }
      
2083.             }
      
2084. 
      
2085. 
      
2086.         //
      
2087.         // If feedback is forced on, turn it on. If forced off, turn it off.
      
2088.         // Off overrides on.
      
2089.         //
      
2090. 
      
2091.         if (StartupInfo.dwFlags & STARTF_FORCEONFEEDBACK)
      
2092.             a->ProcessHandle = (HANDLE)((ULONG_PTR)a->ProcessHandle | 1);
      
2093.         if (StartupInfo.dwFlags & STARTF_FORCEOFFFEEDBACK)
      
2094.             a->ProcessHandle = (HANDLE)((ULONG_PTR)a->ProcessHandle & ~1);
      
2095. 
      
2096.         a->VdmBinaryType = VdmBinaryType; // just tell server the truth
      
2097. 
      
2098.         if (VdmBinaryType){
      
2099.            a->hVDM    = iTask ? 0 : NtCurrentPeb()->ProcessParameters->ConsoleHandle;
      
2100.            a->VdmTask = iTask;
      
2101.         }
      
2102. 
      
2103. #if defined(BUILD_WOW6432)
      
2104.         m.ReturnValue = CsrBasepCreateProcess(a);
      
2105. #else
      
2106.         m.u.CreateProcess = *a;
      
2107.         if (m.u.CreateProcess.Sxs.Flags != 0)
      
2108.         {
      
2109.             const PUNICODE_STRING StringsToCapture[] =
      
2110.             {
      
2111.                 &m.u.CreateProcess.Sxs.Manifest.Path,
      
2112.                     &m.u.CreateProcess.Sxs.Policy.Path,
      
2113.                     &m.u.CreateProcess.Sxs.AssemblyDirectory
      
2114.             };
      
2115. 
      
2116.             Status =
      
2117.                 CsrCaptureMessageMultiUnicodeStringsInPlace(
      
2118.                 &CaptureBuffer,
      
2119.                 RTL_NUMBER_OF(StringsToCapture),
      
2120.                 StringsToCapture
      
2121.                 );
      
2122.             if (!NT_SUCCESS(Status)) {
      
2123.                 BaseSetLastNTError(Status);
      
2124.                 return FALSE;
      
2125.             }
      
2126.         }
      
2127. 
      
2128.         CsrClientCallServer( (PCSR_API_MSG)&m,
      
2129.                              CaptureBuffer,
      
2130.                              CSR_MAKE_API_NUMBER( BASESRV_SERVERDLL_INDEX,
      
2131.                                                   BasepCreateProcess
      
2132.                                                 ),
      
2133.                              sizeof( *a )
      
2134.                            );
      
2135. 
      
2136.         if ( CaptureBuffer ) {
      
2137.             CsrFreeCaptureBuffer( CaptureBuffer );
      
2138.             CaptureBuffer = NULL;
      
2139.         }
      
2140. 
      
2141. #endif
      
2142. 
      
2143.         if (!NT_SUCCESS((NTSTATUS)m.ReturnValue)) {
      
2144.             BaseSetLastNTError((NTSTATUS)m.ReturnValue);
      
2145.             NtTerminateProcess(ProcessHandle, (NTSTATUS)m.ReturnValue);
      
2146.             return FALSE;
      
2147.             }
      
2148. 
      
2149. 
      
2150. 
      
2151.         //
      
2152.         // If the WinSafer sandboxing policy indicates that the
      
2153.         // process needs to be run with a restricted token or placed
      
2154.         // into a restricted job object, then do those actions now.
      
2155.         // Do not replace the token if the restricted token was created
      
2156.         // from a caller supplied token i.e. the CreateProcessAsUser case.
      
2157.         //
      
2158.         if ((hSaferRestrictedToken != NULL) && (hUserToken == NULL)) {
      
2159.             Status = BasepReplaceProcessThreadTokens(
      
2160.                     hSaferRestrictedToken,
      
2161.                     ProcessHandle,
      
2162.                     ThreadHandle);
      
2163.             if (!NT_SUCCESS(Status)) {
      
2164.                 // kill and cleanup.
      
2165.                 NtTerminateProcess(ProcessHandle, Status);
      
2166.                 BaseSetLastNTError(Status);
      
2167.                 return FALSE;
      
2168.             }
      
2169.         }
      
2170.         if (hSaferAssignmentJob != NULL) {
      
2171.             Status = NtAssignProcessToJobObject(
      
2172.                     hSaferAssignmentJob, ProcessHandle);
      
2173.             if (!NT_SUCCESS(Status)) {
      
2174.                 // kill and cleanup.
      
2175.                 NtTerminateProcess(ProcessHandle, STATUS_ACCESS_DENIED);
      
2176.                 BaseSetLastNTError(Status);
      
2177.                 return FALSE;
      
2178.             }
      
2179.         }
      
2180. 
      
2181. 
      
2182.         //
      
2183.         // Make the thread start execution if we are allowed to.
      
2184.         //
      
2185.         if (!( dwCreationFlags & CREATE_SUSPENDED) ) {
      
2186.             NtResumeThread(ThreadHandle,&i);
      
2187.             }
      
2188. 
      
2189. VdmExists:
      
2190.         bStatus = TRUE;
      
2191.         if (VDMCreationState)
      
2192.             VDMCreationState |= VDM_CREATION_SUCCESSFUL;
      
2193. 
      
2194.         try {
      
2195.             if (VdmWaitHandle) {
      
2196. 
      
2197.                 //
      
2198.                 // tag Shared WOW VDM handles so that wait for input idle has a
      
2199.                 // chance to work.  Shared WOW VDM "process" handles are actually
      
2200.                 // event handles,  Separate WOW VDM handles are real process
      
2201.                 // handles. Also mark DOS handles with 0x1 so WaitForInputIdle
      
2202.                 // has a way to distinguish DOS apps and not block forever.
      
2203.                 //
      
2204. 
      
2205.                 if (VdmBinaryType == BINARY_TYPE_WIN16)  {
      
2206.                     lpProcessInformation->hProcess =
      
2207.                             (HANDLE)((ULONG_PTR)VdmWaitHandle | 0x2);
      
2208. 
      
2209.                     //
      
2210.                     // Shared WOW doesn't always start a process, so
      
2211.                     // we don't have a process ID or thread ID to
      
2212.                     // return if the VDM already existed.
      
2213.                     //
      
2214.                     // Separate WOW doesn't hit this codepath
      
2215.                     // (no VdmWaitHandle).
      
2216.                     //
      
2217. 
      
2218.                     if (VDMCreationState & VDM_BEING_REUSED) {
      
2219.                         ClientId.UniqueProcess = 0;
      
2220.                         ClientId.UniqueThread = 0;
      
2221.                         }
      
2222. 
      
2223.                     }
      
2224.                 else  {
      
2225.                     lpProcessInformation->hProcess =
      
2226.                             (HANDLE)((ULONG_PTR)VdmWaitHandle | 0x1);
      
2227.                     }
      
2228. 
      
2229. 
      
2230.                 //
      
2231.                 // Close the ProcessHandle, since we are returning the
      
2232.                 // VdmProcessHandle instead.
      
2233.                 //
      
2234. 
      
2235.                 if (ProcessHandle != NULL)
      
2236.                     NtClose(ProcessHandle);
      
2237.                 }
      
2238.             else{
      
2239.                 lpProcessInformation->hProcess = ProcessHandle;
      
2240.                 }
      
2241. 
      
2242.             lpProcessInformation->hThread = ThreadHandle;
      
2243.             lpProcessInformation->dwProcessId = HandleToUlong(ClientId.UniqueProcess);
      
2244.             lpProcessInformation->dwThreadId = HandleToUlong(ClientId.UniqueThread);
      
2245.             ProcessHandle = NULL;
      
2246.             ThreadHandle = NULL;
      
2247.             }
      
2248.         __except ( EXCEPTION_EXECUTE_HANDLER ) {
      
2249.             NtClose( ProcessHandle );
      
2250.             NtClose( ThreadHandle );
      
2251.             ProcessHandle = NULL;
      
2252.             ThreadHandle = NULL;
      
2253.             if (VDMCreationState)
      
2254.                 VDMCreationState &= ~VDM_CREATION_SUCCESSFUL;
      
2255.             }
      
2256.         }
      
2257.     __finally {
      
2258. 
      
2259.         if (ExePathFullBuffer != NULL) {
      
2260.             SxsWin32ExePath.Buffer = NULL;
      
2261.             SxsWin32ExePath.Length = 0;
      
2262.             SxsWin32ExePath.MaximumLength = 0;
      
2263.             RtlFreeHeap(RtlProcessHeap(), 0, ExePathFullBuffer);
      
2264.             ExePathFullBuffer = NULL;
      
2265.         }
      
2266. 
      
2267.         if (!VdmBinaryType) {
      
2268.             NTSTATUS Status1;
      
2269. 
      
2270.             BasepSxsCloseHandles(&SxsManifestFileHandles);
      
2271.             BasepSxsCloseHandles(&SxsPolicyHandles);
      
2272.             //
      
2273.             // don't close SxsExeHandles, they are
      
2274.             // aliases of other variables that are either closed
      
2275.             // or returned to the caller
      
2276.             //
      
2277. 
      
2278.             //
      
2279.             // This loop only really frees any memory if our computation
      
2280.             // of the overall buffer size was too low, which it is not supposed to be.
      
2281.             //
      
2282.             if (SxsConglomeratedByteBuffer != NULL) {
      
2283.                 for (sxsi= 0 ; sxsi != RTL_NUMBER_OF(SxsStringBuffers) ; ++sxsi) {
      
2284.                     RtlFreeUnicodeStringBuffer(SxsStringBuffers[sxsi]);
      
2285.                     }
      
2286.                 RtlFreeHeap(RtlProcessHeap(), 0,SxsConglomeratedByteBuffer);
      
2287.                 }
      
2288.             }
      
2289.         if (lpEnvironment && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT) ) {
      
2290.             RtlDestroyEnvironment(lpEnvironment);
      
2291.             lpEnvironment = NULL;
      
2292.             }
      
2293.         RtlFreeHeap(RtlProcessHeap(), 0,QuotedBuffer);
      
2294.         RtlFreeHeap(RtlProcessHeap(), 0,NameBuffer);
      
2295.         RtlFreeHeap(RtlProcessHeap(), 0,CurdirBuffer);
      
2296.         RtlFreeHeap(RtlProcessHeap(), 0,FreeBuffer);
      
2297.         if ( FileHandle ) {
      
2298.             NtClose(FileHandle);
      
2299.             }
      
2300.         if ( SectionHandle ) {
      
2301.             NtClose(SectionHandle);
      
2302.             }
      
2303.         if ( ThreadHandle ) {
      
2304.             NtTerminateProcess(ProcessHandle,STATUS_SUCCESS);
      
2305.             NtClose(ThreadHandle);
      
2306.             }
      
2307.         if ( ProcessHandle ) {
      
2308.             NtClose(ProcessHandle);
      
2309.             }
      
2310.         if ( hSaferAssignmentJob ) {
      
2311.             NtClose(hSaferAssignmentJob);
      
2312.             }
      
2313.         if ( hSaferRestrictedToken ) {
      
2314.             if (hUserToken == NULL) {
      
2315.                 // CreateProcess case
      
2316.                 NtClose(hSaferRestrictedToken);
      
2317.                 }
      
2318.             else{
      
2319.                 // CreateProcessAsUser case
      
2320.                 *hRestrictedUserToken = hSaferRestrictedToken;
      
2321.                 }
      
2322.             }
      
2323. 
      
2324.         if (NULL != pAppCompatData) {
      
2325.             RtlFreeHeap(RtlProcessHeap(), 0, pAppCompatData);
      
2326.             }
      
2327. 
      
2328.         if (NULL != pAppCompatSxsData) {
      
2329.             RtlFreeHeap(RtlProcessHeap(), 0, pAppCompatSxsData);
      
2330.             }
      
2331. 
      
2332.         RtlFreeUnicodeString(&VdmNameString);
      
2333.         RtlFreeUnicodeString(&SubSysCommandLine);
      
2334.         if (AnsiStringVDMEnv.Buffer || UnicodeStringVDMEnv.Buffer)
      
2335.             BaseDestroyVDMEnvironment(&AnsiStringVDMEnv, &UnicodeStringVDMEnv);
      
2336. 
      
2337.         if (VDMCreationState && !(VDMCreationState & VDM_CREATION_SUCCESSFUL)){
      
2338.             BaseUpdateVDMEntry (
      
2339.                 UPDATE_VDM_UNDO_CREATION,
      
2340.                 (HANDLE *)&iTask,
      
2341.                 VDMCreationState,
      
2342.                 VdmBinaryType
      
2343.                 );
      
2344.             if(VdmWaitHandle) {
      
2345.                 NtClose(VdmWaitHandle);
      
2346.                 }
      
2347.             }
      
2348.         }
      
2349. 
      
2350.     if (lpEnvironment && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT) ) {
      
2351.         RtlDestroyEnvironment(lpEnvironment);
      
2352.         }
      
2353.     return bStatus;
      
2354. }
      
2355. 
      
2356. BOOL
      
2357. WINAPI
      
2358. CreateProcessW(
      
2359.     LPCWSTR lpApplicationName,
      
2360.     LPWSTR lpCommandLine,
      
2361.     LPSECURITY_ATTRIBUTES lpProcessAttributes,
      
2362.     LPSECURITY_ATTRIBUTES lpThreadAttributes,
      
2363.     BOOL bInheritHandles,
      
2364.     DWORD dwCreationFlags,
      
2365.     LPVOID lpEnvironment,
      
2366.     LPCWSTR lpCurrentDirectory,
      
2367.     LPSTARTUPINFOW lpStartupInfo,
      
2368.     LPPROCESS_INFORMATION lpProcessInformation
      
2369.     )
      
2370. 
      
2371. /*++
      
2372. 
      
2373. Routine Description:
      
2374. 
      
2375.     A process and thread object are created and a handle opened to each
      
2376.     object using CreateProcess.  Note that WinExec and LoadModule are
      
2377.     still supported, but are implemented as a call to CreateProcess.
      
2378. 
      
2379. Arguments:
      
2380. 
      
2381.     lpApplicationName - Supplies an optional pointer to a null terminated
      
2382.         character string that contains the name of the image file to
      
2383.         execute.  This is a fully qualified DOS path name.  If not
      
2384.         specified, then the image file name is the first whitespace
      
2385.         delimited token on the command line.
      
2386. 
      
2387.     lpCommandLine - Supplies a null terminated character string that
      
2388.         contains the command line for the application to be executed.
      
2389.         The entire command line is made available to the new process
      
2390.         using GetCommandLine.  If the lpApplicationName parameter was
      
2391.         not specified, then the first token of the command line
      
2392.         specifies file name of the application (note that this token
      
2393.         begins at the beginning of the command line and ends at the
      
2394.         first "white space" character).  If the file name does not
      
2395.         contain an extension (the presence of a "."), then .EXE is
      
2396.         assumed.  If the file name does not contain a directory path,
      
2397.         Windows will search for the executable file in:
      
2398. 
      
2399.           - The current directory
      
2400. 
      
2401.           - The windows directory
      
2402. 
      
2403.           - The windows system directory
      
2404. 
      
2405.           - The directories listed in the path environment variable
      
2406. 
      
2407.         This parameter is optional onlu if the lpApplicationName
      
2408.         parameter is specified.  In this case the command line the
      
2409.         application receives will be the application name.
      
2410. 
      
2411.     lpProcessAttributes - An optional parameter that may be used to
      
2412.         specify the attributes of the new process.  If the parameter is
      
2413.         not specified, then the process is created without a security
      
2414.         descriptor, and the resulting handle is not inherited on process
      
2415.         creation:
      
2416. 
      
2417.         SECURITY_ATTRIBUTES Structure:
      
2418. 
      
2419.         DWORD nLength - Specifies the length of this structure.  Must be
      
2420.             set to sizeof( SECURITY_ATTRUBUTES ).
      
2421. 
      
2422.         LPVOID lpSecurityDescriptor - Points to a security descriptor for
      
2423.             the object (must be NULL for Win32, used on NT/Win32). The
      
2424.             security descriptor controls the sharing of an object.
      
2425. 
      
2426.         BOOL bInheritHandle - Supplies a flag that indicates whether
      
2427.             or not the returned handle is to be inherited by a new
      
2428.             process during process creation.  A value of TRUE
      
2429.             indicates that the new process will inherit the handle.
      
2430. 
      
2431.     lpThreadAttributes - An optional parameter that may be used to specify
      
2432.         the attributes of the new thread.  If the parameter is not
      
2433.         specified, then the thread is created without a security
      
2434.         descriptor, and the resulting handle is not inherited on
      
2435.         process creation.
      
2436. 
      
2437.     dwCreationFlags - Supplies additional flags that control the creation
      
2438.         of the process.
      
2439. 
      
2440.         dwCreationFlags Flags:
      
2441. 
      
2442.         DEBUG_PROCESS - If this flag bit is set, then the creating
      
2443.             process is treated as a debugger, and the process being
      
2444.             created is created as a debugee.  All debug events occuring
      
2445.             in the debugee are reported to the debugger.  If this bit is
      
2446.             clear, but the calling process is a debugee, then the
      
2447.             process becomes a debugee of the calling processes debugger.
      
2448.             If this bit is clear and the calling processes is not a
      
2449.             debugee then no debug related actions occur.
      
2450. 
      
2451.         DEBUG_ONLY_THIS_PROCESS - If this flag is set, then the
      
2452.             DEBUG_PROCESS flag bit must also be set.  The calling
      
2453.             process is is treated as a debugger, and the new process is
      
2454.             created as its debuggee.  If the new process creates
      
2455.             additional processes, no debug related activities (with
      
2456.             respect to the debugger) occur.
      
2457. 
      
2458.         CREATE_SUSPENDED - The process is created, but the initial thread
      
2459.             of the process remains suspended. The creator can resume this
      
2460.             thread using ResumeThread. Until this is done, code in the
      
2461.             process will not execute.
      
2462. 
      
2463.         CREATE_UNICODE_ENVIRONMENT - If set, the environment pointer
      
2464.             points to a Unicode environment block.  Otherwise, the
      
2465.             block is ANSI (actually OEM.)
      
2466. 
      
2467.     bInheritHandles - Supplies a flag that specifies whether or not the
      
2468.         new process is to inherit handles to objects visible to the
      
2469.         calling process.  A value of TRUE causes handles to be inherited
      
2470.         by the new process.  If TRUE was specified, then for each handle
      
2471.         visible to the calling process, if the handle was created with
      
2472.         the inherit handle option, the handle is inherited to the new
      
2473.         process.  The handle has the same granted access in the new
      
2474.         process as it has in the calling process, and the value of the
      
2475.         handle is the same.
      
2476. 
      
2477.     lpEnvironment - An optional parameter, that if specified, supplies a
      
2478.         pointer to an environment block.  If the parameter is not
      
2479.         specified, the environment block of the current process is used.
      
2480.         This environment block is made available to the new process
      
2481.         using GetEnvironmentStrings.
      
2482. 
      
2483.     lpCurrentDirectory - An optional parameter, that if specified,
      
2484.         supplies a string representing the current drive and directory
      
2485.         for the new process.  The string must be a fully qualified
      
2486.         pathname that includes a drive letter.  If the parameter is not
      
2487.         specified, then the new process is created with the same current
      
2488.         drive and directory as the calling process.  This option is
      
2489.         provided primarily for shells that want to start an application
      
2490.         and specify its initial drive and working directory.
      
2491. 
      
2492.     lpStartupInfo - Supplies information that specified how the
      
2493.         applications window is to be shown. This structure is described
      
2494.         in the Win32 User Interface API Book.
      
2495. 
      
2496.     lpProcessInformation - Returns identification information about the
      
2497.         new process.
      
2498. 
      
2499.     PROCESS_INFORMATION Structure:
      
2500. 
      
2501.         HANDLE hProcess - Returns a handle to the newly created process.
      
2502.             Through the handle, all operations on process objects are
      
2503.             allowed.
      
2504. 
      
2505.         HANDLE hThread - Returns a handle to the newly created thread.
      
2506.             Through the handle, all operations on thread objects are
      
2507.             allowed.
      
2508. 
      
2509.         DWORD dwProcessId - Returns a global process id that may be used
      
2510.             to identify a process.  The value is valid from the time the
      
2511.             process is created until the time the process is terminated.
      
2512. 
      
2513.         DWORD dwThreadId - Returns a global thread id that may be used
      
2514.             to identify a thread.  The value is valid from the time the
      
2515.             thread is created until the time the thread is terminated.
      
2516. 
      
2517. Return Value:
      
2518. 
      
2519.     TRUE - The operation was successful
      
2520. 
      
2521.     FALSE/NULL - The operation failed. Extended error status is available
      
2522.         using GetLastError.
      
2523. 
      
2524. --*/
      
2525. 
      
2526. {
      
2527.     return CreateProcessInternalW(
      
2528.                NULL, // Create new process with the token on the creator process
      
2529.                lpApplicationName,
      
2530.                lpCommandLine,
      
2531.                lpProcessAttributes,
      
2532.                lpThreadAttributes,
      
2533.                bInheritHandles,
      
2534.                dwCreationFlags,
      
2535.                lpEnvironment,
      
2536.                lpCurrentDirectory,
      
2537.                lpStartupInfo,
      
2538.                lpProcessInformation,
      
2539.                NULL  // Do not return the restricted token
      
2540.                );
      
2541. }
      

复制代码