ReactOS  0.4.12-dev-918-g6c6e7b8
proc.c File Reference
#include <k32.h>
#include <debug.h>
Include dependency graph for proc.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define CMD_STRING   L"cmd /c "
 
#define AddToHandle(x, y)   (x) = (HANDLE)((ULONG_PTR)(x) | (y));
 
#define RemoveFromHandle(x, y)   (x) = (HANDLE)((ULONG_PTR)(x) & ~(y));
 

Functions

VOID WINAPI RegisterWaitForInputIdle (WaitForInputIdleType lpfnRegisterWaitForInputIdle)
 
VOID WINAPI StuffStdHandle (IN HANDLE ProcessHandle, IN HANDLE StandardHandle, IN PHANDLE Address)
 
BOOLEAN WINAPI BuildSubSysCommandLine (IN LPCWSTR SubsystemName, IN LPCWSTR ApplicationName, IN LPCWSTR CommandLine, OUT PUNICODE_STRING SubsysCommandLine)
 
BOOLEAN WINAPI BasepIsImageVersionOk (IN ULONG ImageMajorVersion, IN ULONG ImageMinorVersion)
 
NTSTATUS WINAPI BasepCheckWebBladeHashes (IN HANDLE FileHandle)
 
NTSTATUS NTAPI BasepSaveAppCertRegistryValue (IN PLIST_ENTRY List, IN PWCHAR ComponentName, IN PWCHAR DllName)
 
NTSTATUS NTAPI BasepConfigureAppCertDlls (IN PWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData, IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
 
NTSTATUS WINAPI BasepIsProcessAllowed (IN LPWSTR ApplicationName)
 
NTSTATUS WINAPI BasepReplaceProcessThreadTokens (IN HANDLE TokenHandle, IN HANDLE ProcessHandle, IN HANDLE ThreadHandle)
 
VOID WINAPI BasepSxsCloseHandles (IN PBASE_MSG_SXS_HANDLES Handles)
 
VOID WINAPI BaseProcessStartup (PPROCESS_START_ROUTINE lpStartAddress)
 
NTSTATUS WINAPI BasepNotifyCsrOfThread (IN HANDLE ThreadHandle, IN PCLIENT_ID ClientId)
 
BOOLEAN WINAPI BasePushProcessParameters (IN ULONG ParameterFlags, IN HANDLE ProcessHandle, IN PPEB RemotePeb, IN LPCWSTR ApplicationPathName, IN LPWSTR lpCurrentDirectory, IN LPWSTR lpCommandLine, IN LPVOID lpEnvironment, IN LPSTARTUPINFOW StartupInfo, IN DWORD CreationFlags, IN BOOL InheritHandles, IN ULONG ImageSubsystem, IN PVOID AppCompatData, IN ULONG AppCompatDataSize)
 
VOID WINAPI InitCommandLines (VOID)
 
BOOL WINAPI GetProcessAffinityMask (IN HANDLE hProcess, OUT PDWORD_PTR lpProcessAffinityMask, OUT PDWORD_PTR lpSystemAffinityMask)
 
BOOL WINAPI SetProcessAffinityMask (IN HANDLE hProcess, IN DWORD_PTR dwProcessAffinityMask)
 
BOOL WINAPI GetProcessShutdownParameters (OUT LPDWORD lpdwLevel, OUT LPDWORD lpdwFlags)
 
BOOL WINAPI SetProcessShutdownParameters (IN DWORD dwLevel, IN DWORD dwFlags)
 
BOOL WINAPI GetProcessWorkingSetSizeEx (IN HANDLE hProcess, OUT PSIZE_T lpMinimumWorkingSetSize, OUT PSIZE_T lpMaximumWorkingSetSize, OUT PDWORD Flags)
 
BOOL WINAPI GetProcessWorkingSetSize (IN HANDLE hProcess, OUT PSIZE_T lpMinimumWorkingSetSize, OUT PSIZE_T lpMaximumWorkingSetSize)
 
BOOL WINAPI SetProcessWorkingSetSizeEx (IN HANDLE hProcess, IN SIZE_T dwMinimumWorkingSetSize, IN SIZE_T dwMaximumWorkingSetSize, IN DWORD Flags)
 
BOOL WINAPI SetProcessWorkingSetSize (IN HANDLE hProcess, IN SIZE_T dwMinimumWorkingSetSize, IN SIZE_T dwMaximumWorkingSetSize)
 
BOOL WINAPI GetProcessTimes (IN HANDLE hProcess, IN LPFILETIME lpCreationTime, IN LPFILETIME lpExitTime, IN LPFILETIME lpKernelTime, IN LPFILETIME lpUserTime)
 
HANDLE WINAPI GetCurrentProcess (VOID)
 
HANDLE WINAPI GetCurrentThread (VOID)
 
DWORD WINAPI GetCurrentProcessId (VOID)
 
BOOL WINAPI GetExitCodeProcess (IN HANDLE hProcess, IN LPDWORD lpExitCode)
 
DWORD WINAPI GetProcessId (IN HANDLE Process)
 
HANDLE WINAPI OpenProcess (IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
 
VOID WINAPI RegisterWaitForInputIdle (IN WaitForInputIdleType lpfnRegisterWaitForInputIdle)
 
VOID WINAPI GetStartupInfoW (IN LPSTARTUPINFOW lpStartupInfo)
 
VOID WINAPI GetStartupInfoA (IN LPSTARTUPINFOA lpStartupInfo)
 
BOOL WINAPI FlushInstructionCache (IN HANDLE hProcess, IN LPCVOID lpBaseAddress, IN SIZE_T nSize)
 
VOID WINAPI ExitProcess (IN UINT uExitCode)
 
BOOL WINAPI TerminateProcess (IN HANDLE hProcess, IN UINT uExitCode)
 
VOID WINAPI FatalAppExitA (UINT uAction, LPCSTR lpMessageText)
 
VOID WINAPI FatalAppExitW (IN UINT uAction, IN LPCWSTR lpMessageText)
 
VOID WINAPI FatalExit (IN int ExitCode)
 
DWORD WINAPI GetPriorityClass (IN HANDLE hProcess)
 
BOOL WINAPI SetPriorityClass (IN HANDLE hProcess, IN DWORD dwPriorityClass)
 
DWORD WINAPI GetProcessVersion (IN DWORD ProcessId)
 
BOOL WINAPI GetProcessIoCounters (IN HANDLE hProcess, OUT PIO_COUNTERS lpIoCounters)
 
BOOL WINAPI GetProcessPriorityBoost (IN HANDLE hProcess, OUT PBOOL pDisablePriorityBoost)
 
BOOL WINAPI SetProcessPriorityBoost (IN HANDLE hProcess, IN BOOL bDisablePriorityBoost)
 
BOOL WINAPI GetProcessHandleCount (IN HANDLE hProcess, OUT PDWORD pdwHandleCount)
 
BOOL WINAPI IsWow64Process (IN HANDLE hProcess, OUT PBOOL Wow64Process)
 
LPSTR WINAPI GetCommandLineA (VOID)
 
LPWSTR WINAPI GetCommandLineW (VOID)
 
BOOL NTAPI ReadProcessMemory (IN HANDLE hProcess, IN LPCVOID lpBaseAddress, IN LPVOID lpBuffer, IN SIZE_T nSize, OUT SIZE_T *lpNumberOfBytesRead)
 
BOOL NTAPI WriteProcessMemory (IN HANDLE hProcess, IN LPVOID lpBaseAddress, IN LPCVOID lpBuffer, IN SIZE_T nSize, OUT SIZE_T *lpNumberOfBytesWritten)
 
BOOL WINAPI ProcessIdToSessionId (IN DWORD dwProcessId, OUT PDWORD pSessionId)
 
 C_ASSERT (PROCESS_PRIORITY_CLASS_REALTIME==(PROCESS_PRIORITY_CLASS_HIGH+1))
 
BOOL WINAPI CreateProcessInternalW (IN HANDLE hUserToken, IN LPCWSTR lpApplicationName, IN LPWSTR lpCommandLine, IN LPSECURITY_ATTRIBUTES lpProcessAttributes, IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN BOOL bInheritHandles, IN DWORD dwCreationFlags, IN LPVOID lpEnvironment, IN LPCWSTR lpCurrentDirectory, IN LPSTARTUPINFOW lpStartupInfo, IN LPPROCESS_INFORMATION lpProcessInformation, OUT PHANDLE hNewToken)
 
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW (LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
 
BOOL WINAPI CreateProcessInternalA (HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation, PHANDLE hNewToken)
 
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA (LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
 
UINT WINAPI DECLSPEC_HOTPATCH WinExec (LPCSTR lpCmdLine, UINT uCmdShow)
 

Variables

WaitForInputIdleType UserWaitForInputIdleRoutine
 
UNICODE_STRING BaseUnicodeCommandLine
 
ANSI_STRING BaseAnsiCommandLine
 
UNICODE_STRING BasePathVariableName = RTL_CONSTANT_STRING(L"PATH")
 
LPSTARTUPINFOA BaseAnsiStartupInfo = NULL
 
PLDR_DATA_TABLE_ENTRY BasepExeLdrEntry
 
BOOLEAN g_AppCertInitialized
 
BOOLEAN g_HaveAppCerts
 
LIST_ENTRY BasepAppCertDllsList
 
RTL_CRITICAL_SECTION gcsAppCert
 
PBASEP_APPCERT_EMBEDDED_FUNC fEmbeddedCertFunc
 
NTSTATUS g_AppCertStatus
 
RTL_QUERY_REGISTRY_TABLE BasepAppCertTable [2]
 
PSAFER_REPLACE_PROCESS_THREAD_TOKENS g_SaferReplaceProcessThreadTokens
 
HMODULE gSaferHandle = (HMODULE)-1
 

Macro Definition Documentation

◆ AddToHandle

#define AddToHandle (   x,
  y 
)    (x) = (HANDLE)((ULONG_PTR)(x) | (y));

Definition at line 2255 of file proc.c.

◆ CMD_STRING

#define CMD_STRING   L"cmd /c "

Definition at line 51 of file proc.c.

◆ NDEBUG

#define NDEBUG

Definition at line 15 of file proc.c.

◆ RemoveFromHandle

#define RemoveFromHandle (   x,
  y 
)    (x) = (HANDLE)((ULONG_PTR)(x) & ~(y));

Definition at line 2256 of file proc.c.

Function Documentation

◆ BasepCheckWebBladeHashes()

NTSTATUS WINAPI BasepCheckWebBladeHashes ( IN HANDLE  FileHandle)

Definition at line 149 of file proc.c.

150 {
152  CHAR Hash[16];
153 
154  /* Get all the MD5 hashes */
156  if (!NT_SUCCESS(Status)) return Status;
157 
158  /* Depending on which suite this is, run a bsearch and block the appropriate ones */
159  if (SharedUserData->SuiteMask & VER_SUITE_COMPUTE_SERVER)
160  {
161  DPRINT1("Egad! This is a ReactOS Compute Server and we should prevent you from using certain APIs...but we won't.");
162  }
163  else if (SharedUserData->SuiteMask & VER_SUITE_STORAGE_SERVER)
164  {
165  DPRINT1("Gasp! This is a ReactOS Storage Server and we should prevent you from using certain APIs...but we won't.");
166  }
167  else if (SharedUserData->SuiteMask & VER_SUITE_BLADE)
168  {
169  DPRINT1("Golly! This is a ReactOS Web Blade Server and we should prevent you from using certain APIs...but we won't.");
170  }
171 
172  /* Actually, fuck it, don't block anything, we're open source */
173  return STATUS_SUCCESS;
174 }
static int Hash(const char *)
Definition: reader.c:2257
char CHAR
Definition: xmlstorage.h:175
#define VER_SUITE_BLADE
LONG NTSTATUS
Definition: precomp.h:26
NTSYSAPI NTSTATUS NTAPI RtlComputeImportTableHash(IN HANDLE FileHandle, OUT PCHAR Hash, IN ULONG ImportTableHashSize)
Definition: libsupp.c:984
HANDLE FileHandle
Definition: stats.c:38
#define VER_SUITE_STORAGE_SERVER
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define SharedUserData
#define VER_SUITE_COMPUTE_SERVER
Status
Definition: gdiplustypes.h:24
#define DPRINT1
Definition: precomp.h:8
return STATUS_SUCCESS
Definition: btrfs.c:2725

Referenced by CreateProcessInternalW().

◆ BasepConfigureAppCertDlls()

NTSTATUS NTAPI BasepConfigureAppCertDlls ( IN PWSTR  ValueName,
IN ULONG  ValueType,
IN PVOID  ValueData,
IN ULONG  ValueLength,
IN PVOID  Context,
IN PVOID  EntryContext 
)

Definition at line 189 of file proc.c.

195 {
196  /* Add this to the certification list */
198 }
NTSTATUS NTAPI BasepSaveAppCertRegistryValue(IN PLIST_ENTRY List, IN PWCHAR ComponentName, IN PWCHAR DllName)
Definition: proc.c:178
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
_In_ GUID _In_ PVOID ValueData
Definition: hubbusif.h:311

◆ BasepIsImageVersionOk()

BOOLEAN WINAPI BasepIsImageVersionOk ( IN ULONG  ImageMajorVersion,
IN ULONG  ImageMinorVersion 
)

Definition at line 123 of file proc.c.

125 {
126  /* Accept images for NT 3.1 or higher */
127  if (ImageMajorVersion > 3 ||
128  (ImageMajorVersion == 3 && ImageMinorVersion >= 10))
129  {
130  /* ReactOS-specific: Accept images even if they are newer than our internal NT version. */
131  if (ImageMajorVersion > SharedUserData->NtMajorVersion ||
132  (ImageMajorVersion == SharedUserData->NtMajorVersion && ImageMinorVersion > SharedUserData->NtMinorVersion))
133  {
134  DPRINT1("Accepting image version %lu.%lu, although ReactOS is an NT %hu.%hu OS!\n",
135  ImageMajorVersion,
136  ImageMinorVersion,
137  SharedUserData->NtMajorVersion,
138  SharedUserData->NtMinorVersion);
139  }
140 
141  return TRUE;
142  }
143 
144  return FALSE;
145 }
#define TRUE
Definition: types.h:120
#define SharedUserData
#define DPRINT1
Definition: precomp.h:8

Referenced by CreateProcessInternalW().

◆ BasepIsProcessAllowed()

NTSTATUS WINAPI BasepIsProcessAllowed ( IN LPWSTR  ApplicationName)

Definition at line 202 of file proc.c.

203 {
204  NTSTATUS Status, Status1;
205  PWCHAR Buffer;
206  UINT Length;
207  HMODULE TrustLibrary;
209  ULONG CertFlag;
210  PLIST_ENTRY NextEntry;
212  UNICODE_STRING CertKey = RTL_CONSTANT_STRING(L"\\Registry\\MACHINE\\System\\CurrentControlSet\\Control\\Session Manager\\AppCertDlls");
214 
215  /* Try to initialize the certification subsystem */
216  while (!g_AppCertInitialized)
217  {
218  /* Defaults */
220  Buffer = NULL;
221 
222  /* Acquire the lock while initializing and see if we lost a race */
224  if (g_AppCertInitialized) break;
225 
226  /* On embedded, there is a special DLL */
227  if (SharedUserData->SuiteMask & VER_SUITE_EMBEDDEDNT)
228  {
229  /* Allocate a buffer for the name */
230  Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
231  0,
232  MAX_PATH * sizeof(WCHAR) +
233  sizeof(UNICODE_NULL));
234  if (!Buffer)
235  {
236  /* Fail if no memory */
238  }
239  else
240  {
241  /* Now get the system32 directory in our buffer, make sure it fits */
242  Length = GetSystemDirectoryW(Buffer, MAX_PATH - sizeof("EmbdTrst.DLL"));
243  if ((Length) && (Length <= MAX_PATH - sizeof("EmbdTrst.DLL")))
244  {
245  /* Add a slash if needed, and add the embedded cert DLL name */
246  if (Buffer[Length - 1] != '\\') Buffer[Length++] = '\\';
248  L"EmbdTrst.DLL",
249  sizeof(L"EmbdTrst.DLL"));
250 
251  /* Try to load it */
252  TrustLibrary = LoadLibraryW(Buffer);
253  if (TrustLibrary)
254  {
255  /* And extract the special function out of it */
256  fEmbeddedCertFunc = (PVOID)GetProcAddress(TrustLibrary,
257  "ImageOkToRunOnEmbeddedNT");
258  }
259  }
260 
261  /* If we didn't get this far, set a failure code */
263  }
264  }
265  else
266  {
267  /* Other systems have a registry entry for this */
268  Status1 = NtOpenKey(&KeyHandle, KEY_READ, &KeyAttributes);
269  if (NT_SUCCESS(Status1))
270  {
271  /* Close it, we'll query it through Rtl */
273 
274  /* Do the query, which will call a special callback */
276  L"Session Manager",
278  NULL,
279  NULL);
281  {
283  }
284  }
285  }
286 
287  /* Free any buffer if we had one */
288  if (Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
289 
290  /* Check for errors, or a missing embedded/custom certification DLL */
291  if (!NT_SUCCESS(Status) ||
293  {
294  /* The subsystem is not active on this machine, so give up */
297  }
298  else
299  {
300  /* We have certification DLLs active, remember this */
302  }
303 
304  /* We are done the initialization phase, release the lock */
307  }
308 
309  /* If there's no certification DLLs present, return the failure code */
310  if (!g_HaveAppCerts) return g_AppCertStatus;
311 
312  /* Otherwise, assume success and make sure we have *something* */
315 
316  /* If the something is an embedded certification DLL, call it and return */
318 
319  /* Otherwise we have custom certification DLLs, parse them */
320  NextEntry = BasepAppCertDllsList.Flink;
321  CertFlag = 2;
322  while (NextEntry != &BasepAppCertDllsList)
323  {
324  /* Make sure the entry has a callback */
326  ASSERT(Entry->fPluginCertFunc != NULL);
327 
328  /* Call it and check if it failed */
329  Status = Entry->fPluginCertFunc(ApplicationName, 1);
330  if (!NT_SUCCESS(Status)) CertFlag = 3;
331 
332  /* Move on */
333  NextEntry = NextEntry->Flink;
334  }
335 
336  /* Now loop them again */
337  NextEntry = BasepAppCertDllsList.Flink;
338  while (NextEntry != &BasepAppCertDllsList)
339  {
340  /* Make sure the entry has a callback */
342  ASSERT(Entry->fPluginCertFunc != NULL);
343 
344  /* Call it, this time with the flag from the loop above */
345  Status = Entry->fPluginCertFunc(ApplicationName, CertFlag);
346  }
347 
348  /* All done, return the status */
349  return Status;
350 }
NTSTATUS g_AppCertStatus
Definition: proc.c:31
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
RTL_CRITICAL_SECTION gcsAppCert
Definition: proc.c:29
struct _Entry Entry
Definition: kefuncs.h:640
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4693
#define KEY_READ
Definition: nt_native.h:1023
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:603
BOOLEAN g_AppCertInitialized
Definition: proc.c:26
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
uint16_t * PWCHAR
Definition: typedefs.h:54
#define RTL_REGISTRY_CONTROL
Definition: nt_native.h:163
Definition: kernel32.h:383
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
BOOLEAN g_HaveAppCerts
Definition: proc.c:27
#define UNICODE_NULL
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define LoadLibraryW(x)
Definition: compat.h:404
smooth NULL
Definition: ftsmooth.c:416
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:585
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define MAX_PATH
Definition: compat.h:26
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define SharedUserData
static const WCHAR L[]
Definition: oid.c:1250
Definition: typedefs.h:117
Status
Definition: gdiplustypes.h:24
#define RTL_CONSTANT_OBJECT_ATTRIBUTES(n, a)
#define VER_SUITE_EMBEDDEDNT
PVOID PVOID PWCHAR ApplicationName
Definition: env.c:45
RTL_QUERY_REGISTRY_TABLE BasepAppCertTable[2]
Definition: proc.c:32
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
PBASEP_APPCERT_EMBEDDED_FUNC fEmbeddedCertFunc
Definition: proc.c:30
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2312
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
LIST_ENTRY BasepAppCertDllsList
Definition: proc.c:28
unsigned int ULONG
Definition: retypes.h:1
#define GetProcAddress(x, y)
Definition: compat.h:410
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:2725
base of all file and directory entries
Definition: entries.h:82
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14

Referenced by CreateProcessInternalW().

◆ BasepNotifyCsrOfThread()

NTSTATUS WINAPI BasepNotifyCsrOfThread ( IN HANDLE  ThreadHandle,
IN PCLIENT_ID  ClientId 
)

Definition at line 484 of file proc.c.

486 {
487  BASE_API_MESSAGE ApiMessage;
488  PBASE_CREATE_THREAD CreateThreadRequest = &ApiMessage.Data.CreateThreadRequest;
489 
490  DPRINT("BasepNotifyCsrOfThread: Thread: %p, Handle %p\n",
491  ClientId->UniqueThread, ThreadHandle);
492 
493  /* Fill out the request */
494  CreateThreadRequest->ClientId = *ClientId;
495  CreateThreadRequest->ThreadHandle = ThreadHandle;
496 
497  /* Call CSR */
499  NULL,
501  sizeof(*CreateThreadRequest));
502  if (!NT_SUCCESS(ApiMessage.Status))
503  {
504  DPRINT1("Failed to tell CSRSS about new thread: %lx\n", ApiMessage.Status);
505  return ApiMessage.Status;
506  }
507 
508  /* Return Success */
509  return STATUS_SUCCESS;
510 }
BASE_CREATE_THREAD CreateThreadRequest
Definition: basemsg.h:284
union _BASE_API_MESSAGE::@3379 Data
NTSTATUS NTAPI CsrClientCallServer(IN OUT PCSR_API_MESSAGE ApiMessage, IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer OPTIONAL, IN CSR_API_NUMBER ApiNumber, IN ULONG DataLength)
Definition: connect.c:360
NTSTATUS Status
Definition: csrmsg.h:112
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
HANDLE ThreadHandle
Definition: basemsg.h:104
#define CSR_CREATE_API_NUMBER(ServerId, ApiId)
Definition: csrmsg.h:37
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
#define BASESRV_SERVERDLL_INDEX
Definition: basemsg.h:15
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
CLIENT_ID ClientId
Definition: basemsg.h:105
HANDLE UniqueThread
Definition: compat.h:475
#define DPRINT1
Definition: precomp.h:8
return STATUS_SUCCESS
Definition: btrfs.c:2725

Referenced by CreateRemoteThread().

◆ BasepReplaceProcessThreadTokens()

NTSTATUS WINAPI BasepReplaceProcessThreadTokens ( IN HANDLE  TokenHandle,
IN HANDLE  ProcessHandle,
IN HANDLE  ThreadHandle 
)

Definition at line 354 of file proc.c.

357 {
359  ANSI_STRING SaferiReplaceProcessThreadTokens = RTL_CONSTANT_STRING("SaferiReplaceProcessThreadTokens");
360 
361  /* Enter the application certification lock */
363 
364  /* Check if we already know the function */
366  {
367  /* Call it */
370  ThreadHandle) ?
373  }
374  else
375  {
376  /* Check if the app certification DLL isn't loaded */
377  if (!(gSaferHandle) ||
378  (gSaferHandle == (HMODULE)-1) ||
379  (gSaferHandle == (HMODULE)-2))
380  {
381  /* Then we can't call the function */
383  }
384  else
385  {
386  /* We have the DLL, find the address of the Safer function */
388  &SaferiReplaceProcessThreadTokens,
389  0,
391  if (NT_SUCCESS(Status))
392  {
393  /* Found it, now call it */
396  ThreadHandle) ?
399  }
400  else
401  {
402  /* We couldn't find it, so this must be an unsupported DLL */
404  gSaferHandle = NULL;
406  }
407  }
408  }
409 
410  /* Release the lock and return the result */
412  return Status;
413 }
RTL_CRITICAL_SECTION gcsAppCert
Definition: proc.c:29
LONG NTSTATUS
Definition: precomp.h:26
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
PSAFER_REPLACE_PROCESS_THREAD_TOKENS g_SaferReplaceProcessThreadTokens
Definition: proc.c:45
NTSTATUS NTAPI LdrGetProcedureAddress(IN PVOID BaseAddress, IN PANSI_STRING Name, IN ULONG Ordinal, OUT PVOID *ProcedureAddress)
Definition: ldrapi.c:823
smooth NULL
Definition: ftsmooth.c:416
_In_ ACCESS_MASK _In_ ULONG _Out_ PHANDLE TokenHandle
Definition: psfuncs.h:715
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
Status
Definition: gdiplustypes.h:24
NTSTATUS NTAPI LdrUnloadDll(IN PVOID BaseAddress)
Definition: ldrapi.c:1322
HMODULE gSaferHandle
Definition: proc.c:46
#define STATUS_ENTRYPOINT_NOT_FOUND
Definition: ntstatus.h:535
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
return STATUS_SUCCESS
Definition: btrfs.c:2725
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14

Referenced by CreateProcessInternalW().

◆ BaseProcessStartup()

VOID WINAPI BaseProcessStartup ( PPROCESS_START_ROUTINE  lpStartAddress)

Definition at line 450 of file proc.c.

451 {
452  DPRINT("BaseProcessStartup(..) - setting up exception frame.\n");
453 
454  _SEH2_TRY
455  {
456  /* Set our Start Address */
459  &lpStartAddress,
460  sizeof(PPROCESS_START_ROUTINE));
461 
462  /* Call the Start Routine */
463  ExitThread(lpStartAddress());
464  }
466  {
467  /* Get the Exit code from the SEH Handler */
469  {
470  /* Kill the whole process, usually */
472  }
473  else
474  {
475  /* If running inside CSRSS, kill just this thread */
477  }
478  }
479  _SEH2_END;
480 }
#define NtCurrentThread()
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1517
_SEH2_TRY
Definition: create.c:4250
LONG WINAPI UnhandledExceptionFilter(IN PEXCEPTION_POINTERS ExceptionInfo)
Definition: except.c:262
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:11
void DPRINT(...)
Definition: polytest.cpp:61
VOID WINAPI ExitThread(IN DWORD uExitCode)
Definition: thread.c:327
NTSTATUS NTAPI NtSetInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength)
Definition: query.c:1967
BOOLEAN BaseRunningInServerProcess
Definition: dllmain.c:20
_SEH2_END
Definition: create.c:4424
UINT(WINAPI * PPROCESS_START_ROUTINE)(VOID)
Definition: kernel32.h:246
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12

◆ BasepSaveAppCertRegistryValue()

NTSTATUS NTAPI BasepSaveAppCertRegistryValue ( IN PLIST_ENTRY  List,
IN PWCHAR  ComponentName,
IN PWCHAR  DllName 
)

Definition at line 178 of file proc.c.

181 {
182  /* Pretty much the only thing this key is used for, is malware */
184  return STATUS_NOT_IMPLEMENTED;
185 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by BasepConfigureAppCertDlls().

◆ BasepSxsCloseHandles()

VOID WINAPI BasepSxsCloseHandles ( IN PBASE_MSG_SXS_HANDLES  Handles)

Definition at line 417 of file proc.c.

418 {
420 
421  /* Sanity checks */
422  ASSERT(Handles != NULL);
423  ASSERT(Handles->Process == NULL || Handles->Process == NtCurrentProcess());
424 
425  /* Close the file handle */
426  if (Handles->File)
427  {
428  Status = NtClose(Handles->File);
430  }
431 
432  /* Close the section handle */
433  if (Handles->Section)
434  {
435  Status = NtClose(Handles->Section);
437  }
438 
439  /* Unmap the section view */
440  if (Handles->ViewBase.QuadPart)
441  {
443  (PVOID)(ULONG_PTR)Handles->ViewBase.QuadPart);
445  }
446 }
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3780
LONG NTSTATUS
Definition: precomp.h:26
uint32_t ULONG_PTR
Definition: typedefs.h:63
smooth NULL
Definition: ftsmooth.c:416
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Status
Definition: gdiplustypes.h:24

Referenced by CreateProcessInternalW().

◆ BasePushProcessParameters()

BOOLEAN WINAPI BasePushProcessParameters ( IN ULONG  ParameterFlags,
IN HANDLE  ProcessHandle,
IN PPEB  RemotePeb,
IN LPCWSTR  ApplicationPathName,
IN LPWSTR  lpCurrentDirectory,
IN LPWSTR  lpCommandLine,
IN LPVOID  lpEnvironment,
IN LPSTARTUPINFOW  StartupInfo,
IN DWORD  CreationFlags,
IN BOOL  InheritHandles,
IN ULONG  ImageSubsystem,
IN PVOID  AppCompatData,
IN ULONG  AppCompatDataSize 
)

Definition at line 514 of file proc.c.

527 {
528  WCHAR FullPath[MAX_PATH + 5];
529  PWCHAR Remaining, DllPathString, ScanChar;
530  PRTL_USER_PROCESS_PARAMETERS ProcessParameters, RemoteParameters;
531  PVOID RemoteAppCompatData;
533  UNICODE_STRING Desktop, Shell, Runtime, Title;
535  ULONG EnviroSize;
536  SIZE_T Size;
537  BOOLEAN HavePebLock = FALSE, Result;
538  PPEB Peb = NtCurrentPeb();
539 
540  /* Get the full path name */
541  Size = GetFullPathNameW(ApplicationPathName,
542  MAX_PATH + 4,
543  FullPath,
544  &Remaining);
545  if ((Size) && (Size <= (MAX_PATH + 4)))
546  {
547  /* Get the DLL Path */
548  DllPathString = BaseComputeProcessDllPath(FullPath, lpEnvironment);
549  if (!DllPathString)
550  {
551  /* Fail */
553  return FALSE;
554  }
555 
556  /* Initialize Strings */
557  RtlInitUnicodeString(&DllPath, DllPathString);
558  RtlInitUnicodeString(&ImageName, FullPath);
559  }
560  else
561  {
562  /* Couldn't get the path name. Just take the original path */
563  DllPathString = BaseComputeProcessDllPath((LPWSTR)ApplicationPathName,
564  lpEnvironment);
565  if (!DllPathString)
566  {
567  /* Fail */
569  return FALSE;
570  }
571 
572  /* Initialize Strings */
573  RtlInitUnicodeString(&DllPath, DllPathString);
574  RtlInitUnicodeString(&ImageName, ApplicationPathName);
575  }
576 
577  /* Initialize Strings */
578  RtlInitUnicodeString(&CommandLine, lpCommandLine);
579  RtlInitUnicodeString(&CurrentDirectory, lpCurrentDirectory);
580 
581  /* Initialize more Strings from the Startup Info */
582  if (StartupInfo->lpDesktop)
583  {
584  RtlInitUnicodeString(&Desktop, StartupInfo->lpDesktop);
585  }
586  else
587  {
589  }
590  if (StartupInfo->lpReserved)
591  {
592  RtlInitUnicodeString(&Shell, StartupInfo->lpReserved);
593  }
594  else
595  {
597  }
598  if (StartupInfo->lpTitle)
599  {
600  RtlInitUnicodeString(&Title, StartupInfo->lpTitle);
601  }
602  else
603  {
604  RtlInitUnicodeString(&Title, ApplicationPathName);
605  }
606 
607  /* This one is special because the length can differ */
608  Runtime.Buffer = (LPWSTR)StartupInfo->lpReserved2;
609  Runtime.MaximumLength = Runtime.Length = StartupInfo->cbReserved2;
610 
611  /* Enforce no app compat data if the pointer was NULL */
612  if (!AppCompatData) AppCompatDataSize = 0;
613 
614  /* Create the Parameter Block */
615  ProcessParameters = NULL;
616  DPRINT("ImageName: '%wZ'\n", &ImageName);
617  DPRINT("DllPath : '%wZ'\n", &DllPath);
618  DPRINT("CurDir : '%wZ'\n", &CurrentDirectory);
619  DPRINT("CmdLine : '%wZ'\n", &CommandLine);
620  DPRINT("Title : '%wZ'\n", &Title);
621  DPRINT("Desktop : '%wZ'\n", &Desktop);
622  DPRINT("Shell : '%wZ'\n", &Shell);
623  DPRINT("Runtime : '%wZ'\n", &Runtime);
624  Status = RtlCreateProcessParameters(&ProcessParameters,
625  &ImageName,
626  &DllPath,
627  lpCurrentDirectory ?
629  &CommandLine,
630  lpEnvironment,
631  &Title,
632  &Desktop,
633  &Shell,
634  &Runtime);
635  if (!NT_SUCCESS(Status)) goto FailPath;
636 
637  /* Clear the current directory handle if not inheriting */
638  if (!InheritHandles) ProcessParameters->CurrentDirectory.Handle = NULL;
639 
640  /* Check if the user passed in an environment */
641  if (lpEnvironment)
642  {
643  /* We should've made it part of the parameters block, enforce this */
644  ASSERT(ProcessParameters->Environment == lpEnvironment);
645  lpEnvironment = ProcessParameters->Environment;
646  }
647  else
648  {
649  /* The user did not, so use the one from the current PEB */
650  HavePebLock = TRUE;
652  lpEnvironment = Peb->ProcessParameters->Environment;
653  }
654 
655  /* Save pointer and start lookup */
656  ScanChar = lpEnvironment;
657  if (lpEnvironment)
658  {
659  /* Find the environment size */
660  while (*ScanChar++) while (*ScanChar++);
661  EnviroSize = (ULONG)((ULONG_PTR)ScanChar - (ULONG_PTR)lpEnvironment);
662 
663  /* Allocate and Initialize new Environment Block */
664  Size = EnviroSize;
665  ProcessParameters->Environment = NULL;
667  (PVOID*)&ProcessParameters->Environment,
668  0,
669  &Size,
670  MEM_COMMIT,
672  if (!NT_SUCCESS(Status)) goto FailPath;
673 
674  /* Write the Environment Block */
676  ProcessParameters->Environment,
677  lpEnvironment,
678  EnviroSize,
679  NULL);
680 
681  /* No longer need the PEB lock anymore */
682  if (HavePebLock)
683  {
684  /* Release it */
686  HavePebLock = FALSE;
687  }
688 
689  /* Check if the write failed */
690  if (!NT_SUCCESS(Status)) goto FailPath;
691  }
692 
693  /* Write new parameters */
694  ProcessParameters->StartingX = StartupInfo->dwX;
695  ProcessParameters->StartingY = StartupInfo->dwY;
696  ProcessParameters->CountX = StartupInfo->dwXSize;
697  ProcessParameters->CountY = StartupInfo->dwYSize;
698  ProcessParameters->CountCharsX = StartupInfo->dwXCountChars;
699  ProcessParameters->CountCharsY = StartupInfo->dwYCountChars;
700  ProcessParameters->FillAttribute = StartupInfo->dwFillAttribute;
701  ProcessParameters->WindowFlags = StartupInfo->dwFlags;
702  ProcessParameters->ShowWindowFlags = StartupInfo->wShowWindow;
703 
704  /* Write the handles only if we have to */
705  if (StartupInfo->dwFlags &
706  (STARTF_USESTDHANDLES | STARTF_USEHOTKEY | STARTF_SHELLPRIVATE))
707  {
708  ProcessParameters->StandardInput = StartupInfo->hStdInput;
709  ProcessParameters->StandardOutput = StartupInfo->hStdOutput;
710  ProcessParameters->StandardError = StartupInfo->hStdError;
711  }
712 
713  /* Use Special Flags for ConDllInitialize in Kernel32 */
714  if (CreationFlags & DETACHED_PROCESS)
715  {
716  ProcessParameters->ConsoleHandle = HANDLE_DETACHED_PROCESS;
717  }
718  else if (CreationFlags & CREATE_NEW_CONSOLE)
719  {
720  ProcessParameters->ConsoleHandle = HANDLE_CREATE_NEW_CONSOLE;
721  }
722  else if (CreationFlags & CREATE_NO_WINDOW)
723  {
724  ProcessParameters->ConsoleHandle = HANDLE_CREATE_NO_WINDOW;
725  }
726  else
727  {
728  /* Inherit our Console Handle */
729  ProcessParameters->ConsoleHandle = Peb->ProcessParameters->ConsoleHandle;
730 
731  /* Make sure that the shell isn't trampling on our handles first */
732  if (!(StartupInfo->dwFlags &
733  (STARTF_USESTDHANDLES | STARTF_USEHOTKEY | STARTF_SHELLPRIVATE)))
734  {
735  /* Copy the handle if we are inheriting or if it's a console handle */
736  if ((InheritHandles) ||
738  {
739  ProcessParameters->StandardInput = Peb->ProcessParameters->StandardInput;
740  }
741  if ((InheritHandles) ||
743  {
744  ProcessParameters->StandardOutput = Peb->ProcessParameters->StandardOutput;
745  }
746  if ((InheritHandles) ||
748  {
749  ProcessParameters->StandardError = Peb->ProcessParameters->StandardError;
750  }
751  }
752  }
753 
754  /* Also set the Console Flag */
755  if ((CreationFlags & CREATE_NEW_PROCESS_GROUP) &&
756  (!(CreationFlags & CREATE_NEW_CONSOLE)))
757  {
758  ProcessParameters->ConsoleFlags = 1;
759  }
760 
761  /* Check if there's a .local file present */
762  if (ParameterFlags & 1)
763  {
765  }
766 
767  /* Check if we failed to open the IFEO key */
768  if (ParameterFlags & 2)
769  {
771  }
772 
773  /* Allocate memory for the parameter block */
774  Size = ProcessParameters->Length;
775  RemoteParameters = NULL;
777  (PVOID*)&RemoteParameters,
778  0,
779  &Size,
780  MEM_COMMIT,
782  if (!NT_SUCCESS(Status)) goto FailPath;
783 
784  /* Set the allocated size */
785  ProcessParameters->MaximumLength = Size;
786 
787  /* Handle some Parameter Flags */
788  ProcessParameters->Flags |= (CreationFlags & PROFILE_USER) ?
790  ProcessParameters->Flags |= (CreationFlags & PROFILE_KERNEL) ?
792  ProcessParameters->Flags |= (CreationFlags & PROFILE_SERVER) ?
794  ProcessParameters->Flags |= (Peb->ProcessParameters->Flags &
796 
797  /* Write the Parameter Block */
799  RemoteParameters,
800  ProcessParameters,
801  ProcessParameters->Length,
802  NULL);
803  if (!NT_SUCCESS(Status)) goto FailPath;
804 
805  /* Write the PEB Pointer */
807  &RemotePeb->ProcessParameters,
808  &RemoteParameters,
809  sizeof(PVOID),
810  NULL);
811  if (!NT_SUCCESS(Status)) goto FailPath;
812 
813  /* Check if there's any app compat data to write */
814  RemoteAppCompatData = NULL;
815  if (AppCompatData)
816  {
817  /* Allocate some space for the application compatibility data */
818  Size = AppCompatDataSize;
820  &RemoteAppCompatData,
821  0,
822  &Size,
823  MEM_COMMIT,
825  if (!NT_SUCCESS(Status)) goto FailPath;
826 
827  /* Write the application compatibility data */
829  RemoteAppCompatData,
830  AppCompatData,
831  AppCompatDataSize,
832  NULL);
833  if (!NT_SUCCESS(Status)) goto FailPath;
834  }
835 
836  /* Write the PEB Pointer to the app compat data (might be NULL) */
838  &RemotePeb->pShimData,
839  &RemoteAppCompatData,
840  sizeof(PVOID),
841  NULL);
842  if (!NT_SUCCESS(Status)) goto FailPath;
843 
844  /* Now write Peb->ImageSubSystem */
845  if (ImageSubsystem)
846  {
848  &RemotePeb->ImageSubsystem,
849  &ImageSubsystem,
850  sizeof(ImageSubsystem),
851  NULL);
852  }
853 
854  /* Success path */
855  Result = TRUE;
856 
857 Quickie:
858  /* Cleanup */
859  if (HavePebLock) RtlReleasePebLock();
860  RtlFreeHeap(RtlGetProcessHeap(), 0, DllPath.Buffer);
861  if (ProcessParameters) RtlDestroyProcessParameters(ProcessParameters);
862  return Result;
863 FailPath:
864  DPRINT1("Failure to create process parameters: %lx\n", Status);
866  Result = FALSE;
867  goto Quickie;
868 }
NTSYSAPI NTSTATUS NTAPI RtlCreateProcessParameters(_Out_ PRTL_USER_PROCESS_PARAMETERS *ProcessParameters, _In_ PUNICODE_STRING ImagePathName, _In_opt_ PUNICODE_STRING DllPath, _In_opt_ PUNICODE_STRING CurrentDirectory, _In_opt_ PUNICODE_STRING CommandLine, _In_opt_ PWSTR Environment, _In_opt_ PUNICODE_STRING WindowTitle, _In_opt_ PUNICODE_STRING DesktopInfo, _In_opt_ PUNICODE_STRING ShellInfo, _In_opt_ PUNICODE_STRING RuntimeInfo)
#define TRUE
Definition: types.h:120
PPEB Peb
Definition: dllmain.c:27
#define RTL_USER_PROCESS_PARAMETERS_IMAGE_KEY_MISSING
Definition: rtltypes.h:54
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define HANDLE_DETACHED_PROCESS
Definition: console.h:13
#define HANDLE_CREATE_NO_WINDOW
Definition: console.h:15
WCHAR CurrentDirectory[1024]
Definition: chkdsk.c:74
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:603
#define PROFILE_KERNEL
Definition: winbase.h:197
NTSYSAPI NTSTATUS NTAPI RtlDestroyProcessParameters(_In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters)
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1105
VOID NTAPI RtlReleasePebLock(VOID)
Definition: libsupp.c:82
uint16_t * PWCHAR
Definition: typedefs.h:54
#define CREATE_NEW_PROCESS_GROUP
Definition: winbase.h:185
#define MEM_COMMIT
Definition: nt_native.h:1313
#define PROFILE_USER
Definition: winbase.h:196
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define CREATE_NO_WINDOW
Definition: winbase.h:195
#define STARTF_SHELLPRIVATE
Definition: kernel32.h:60
#define RTL_USER_PROCESS_PARAMETERS_PROFILE_USER
Definition: rtltypes.h:42
unsigned char BOOLEAN
#define RTL_USER_PROCESS_PARAMETERS_PROFILE_KERNEL
Definition: rtltypes.h:43
smooth NULL
Definition: ftsmooth.c:416
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
void DPRINT(...)
Definition: polytest.cpp:61
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
static CHAR Desktop[MAX_PATH]
Definition: dem.c:256
#define STARTF_USESTDHANDLES
Definition: winbase.h:480
#define HANDLE_CREATE_NEW_CONSOLE
Definition: console.h:14
#define CREATE_NEW_CONSOLE
Definition: winbase.h:180
static const WCHAR Title[]
Definition: oid.c:1259
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define RTL_USER_PROCESS_PARAMETERS_PROFILE_SERVER
Definition: rtltypes.h:44
#define MAX_PATH
Definition: compat.h:26
#define SetLastError(x)
Definition: compat.h:409
#define IsConsoleHandle(h)
Definition: console.h:14
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
static const char * ImageName
Definition: image.c:34
static const WCHAR L[]
Definition: oid.c:1250
#define RTL_USER_PROCESS_PARAMETERS_DISABLE_HEAP_CHECKS
Definition: rtltypes.h:49
PRTL_USER_PROCESS_PARAMETERS ProcessParameters
Definition: btrfs_drv.h:1838
static int Shell(const char **args)
Definition: vfdcmd.c:1020
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
Status
Definition: gdiplustypes.h:24
LPWSTR WINAPI BaseComputeProcessDllPath(IN LPWSTR FullPath, IN PVOID Environment)
Definition: path.c:420
ULONG_PTR SIZE_T
Definition: typedefs.h:78
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4367
#define NtCurrentPeb()
Definition: FLS.c:19
static const char const char * DllPath
Definition: image.c:34
#define DETACHED_PROCESS
Definition: winbase.h:179
VOID NTAPI RtlAcquirePebLock(VOID)
Definition: libsupp.c:72
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
HANDLE Handle
Definition: rtltypes.h:1363
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define ULONG_PTR
Definition: config.h:101
#define PROFILE_SERVER
Definition: winbase.h:198
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define RTL_USER_PROCESS_PARAMETERS_LOCAL_DLL_PATH
Definition: rtltypes.h:53
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
NTSTATUS NTAPI NtWriteVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, IN PVOID Buffer, IN SIZE_T NumberOfBytesToWrite, OUT PSIZE_T NumberOfBytesWritten OPTIONAL)
Definition: virtual.c:2805
#define PAGE_READWRITE
Definition: nt_native.h:1304

Referenced by CreateProcessInternalW().

◆ BuildSubSysCommandLine()

BOOLEAN WINAPI BuildSubSysCommandLine ( IN LPCWSTR  SubsystemName,
IN LPCWSTR  ApplicationName,
IN LPCWSTR  CommandLine,
OUT PUNICODE_STRING  SubsysCommandLine 
)

Definition at line 89 of file proc.c.

93 {
94  UNICODE_STRING CommandLineString, ApplicationNameString;
95  PWCHAR Buffer;
96  ULONG Length;
97 
98  /* Convert to unicode strings */
99  RtlInitUnicodeString(&CommandLineString, ApplicationName);
100  RtlInitUnicodeString(&ApplicationNameString, CommandLine);
101 
102  /* Allocate buffer for the output string */
103  Length = CommandLineString.MaximumLength + ApplicationNameString.MaximumLength + 32;
104  Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length);
105  RtlInitEmptyUnicodeString(SubsysCommandLine, Buffer, (USHORT)Length);
106  if (!Buffer)
107  {
108  /* Fail, no memory */
110  return FALSE;
111  }
112 
113  /* Build the final subsystem command line */
114  RtlAppendUnicodeToString(SubsysCommandLine, SubsystemName);
115  RtlAppendUnicodeStringToString(SubsysCommandLine, &CommandLineString);
116  RtlAppendUnicodeToString(SubsysCommandLine, L" /C ");
117  RtlAppendUnicodeStringToString(SubsysCommandLine, &ApplicationNameString);
118  return TRUE;
119 }
#define TRUE
Definition: types.h:120
USHORT MaximumLength
Definition: env_spec_w32.h:370
uint16_t * PWCHAR
Definition: typedefs.h:54
Definition: bufpool.h:45
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:585
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
static const WCHAR L[]
Definition: oid.c:1250
PVOID PVOID PWCHAR ApplicationName
Definition: env.c:45
unsigned short USHORT
Definition: pedump.c:61
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34

Referenced by CreateProcessInternalW().

◆ C_ASSERT()

◆ CreateProcessA()

BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA ( LPCSTR  lpApplicationName,
LPSTR  lpCommandLine,
LPSECURITY_ATTRIBUTES  lpProcessAttributes,
LPSECURITY_ATTRIBUTES  lpThreadAttributes,
BOOL  bInheritHandles,
DWORD  dwCreationFlags,
LPVOID  lpEnvironment,
LPCSTR  lpCurrentDirectory,
LPSTARTUPINFOA  lpStartupInfo,
LPPROCESS_INFORMATION  lpProcessInformation 
)

Definition at line 4772 of file proc.c.

4782 {
4783  /* Call the internal (but exported) version */
4785  lpApplicationName,
4786  lpCommandLine,
4787  lpProcessAttributes,
4788  lpThreadAttributes,
4789  bInheritHandles,
4790  dwCreationFlags,
4791  lpEnvironment,
4792  lpCurrentDirectory,
4793  lpStartupInfo,
4794  lpProcessInformation,
4795  NULL);
4796 }
BOOL WINAPI CreateProcessInternalA(HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation, PHANDLE hNewToken)
Definition: proc.c:4654
smooth NULL
Definition: ftsmooth.c:416

Referenced by _create_process(), cmd_available(), CommandThreadProc(), crash_and_debug(), crash_and_winedbg(), create_proc(), create_process(), create_server_process(), create_target_process(), create_writepipe_process(), CreateProcessAsUserA(), do_parent(), doChildren(), fork_helper(), IDirectPlayLobby3AImpl_RunApplication(), LoadModule(), run_child_process(), run_client(), run_cmd(), run_ex(), run_process(), run_reg_exe_(), run_regedit_exe_(), run_script_file(), runcmd(), start_server(), START_TEST(), system(), test___getmainargs_parent(), test_alloc_shared(), test_apc_deadlock(), test_BreakawayOk(), test_comctl32_classes(), test_CommandLine(), test_Console(), test_CreateProcessWithDesktop(), test_debug_children(), test_debug_heap(), test_debug_loop(), test_DebuggingFlag(), test_DetachConsoleHandles(), test_DetachStdHandles(), test_Directory(), test_EnumProcessModules(), test_Environment(), test_ExitCode(), test_ExitProcess(), test_GetProcessVersion(), test_internet_features(), test_invalid_stdin(), test_IsWow64Process(), test_jobInheritance(), test_LresultFromObject(), test_NonExistentPath(), test_NtSuspendProcess(), test_process_access(), test_process_security(), test_query_process_debug_flags(), test_query_process_debug_object_handle(), test_query_process_debug_port(), test_section_access(), test_shared_memory(), test_shared_memory_ro(), test_Startup(), test_StartupNoConsole(), test_stdout_handle(), test_SuspendFlag(), test_TerminateProcess(), test_token_security_descriptor(), test_Toolhelp(), test_WaitForInputIdle(), test_window_from_point(), test_winproc_handles(), and WinExec().

◆ CreateProcessInternalA()

BOOL WINAPI CreateProcessInternalA ( HANDLE  hToken,
LPCSTR  lpApplicationName,
LPSTR  lpCommandLine,
LPSECURITY_ATTRIBUTES  lpProcessAttributes,
LPSECURITY_ATTRIBUTES  lpThreadAttributes,
BOOL  bInheritHandles,
DWORD  dwCreationFlags,
LPVOID  lpEnvironment,
LPCSTR  lpCurrentDirectory,
LPSTARTUPINFOA  lpStartupInfo,
LPPROCESS_INFORMATION  lpProcessInformation,
PHANDLE  hNewToken 
)

Definition at line 4654 of file proc.c.

4666 {
4667  UNICODE_STRING CommandLine;
4670  BOOL bRetVal;
4671  STARTUPINFOW StartupInfo;
4672 
4673  DPRINT("dwCreationFlags %x, lpEnvironment %p, lpCurrentDirectory %p, "
4674  "lpStartupInfo %p, lpProcessInformation %p\n",
4675  dwCreationFlags, lpEnvironment, lpCurrentDirectory,
4676  lpStartupInfo, lpProcessInformation);
4677 
4678  /* Copy Startup Info */
4679  RtlMoveMemory(&StartupInfo, lpStartupInfo, sizeof(*lpStartupInfo));
4680 
4681  /* Initialize all strings to nothing */
4682  CommandLine.Buffer = NULL;
4683  ApplicationName.Buffer = NULL;
4684  CurrentDirectory.Buffer = NULL;
4685  StartupInfo.lpDesktop = NULL;
4686  StartupInfo.lpReserved = NULL;
4687  StartupInfo.lpTitle = NULL;
4688 
4689  /* Convert the Command line */
4690  if (lpCommandLine)
4691  {
4693  lpCommandLine);
4694  }
4695 
4696  /* Convert the Name and Directory */
4697  if (lpApplicationName)
4698  {
4700  lpApplicationName);
4701  }
4702  if (lpCurrentDirectory)
4703  {
4705  lpCurrentDirectory);
4706  }
4707 
4708  /* Now convert Startup Strings */
4709  if (lpStartupInfo->lpReserved)
4710  {
4712  &StartupInfo.lpReserved);
4713  }
4714  if (lpStartupInfo->lpDesktop)
4715  {
4717  &StartupInfo.lpDesktop);
4718  }
4719  if (lpStartupInfo->lpTitle)
4720  {
4722  &StartupInfo.lpTitle);
4723  }
4724 
4725  /* Call the Unicode function */
4726  bRetVal = CreateProcessInternalW(hToken,
4727  ApplicationName.Buffer,
4728  CommandLine.Buffer,
4729  lpProcessAttributes,
4730  lpThreadAttributes,
4731  bInheritHandles,
4732  dwCreationFlags,
4733  lpEnvironment,
4734  CurrentDirectory.Buffer,
4735  &StartupInfo,
4736  lpProcessInformation,
4737  hNewToken);
4738 
4739  /* Clean up */
4741  RtlFreeUnicodeString(&CommandLine);
4743  RtlFreeHeap(RtlGetProcessHeap(), 0, StartupInfo.lpDesktop);
4744  RtlFreeHeap(RtlGetProcessHeap(), 0, StartupInfo.lpReserved);
4745  RtlFreeHeap(RtlGetProcessHeap(), 0, StartupInfo.lpTitle);
4746 
4747  /* Return what Unicode did */
4748  return bRetVal;
4749 }
BOOL WINAPI CreateProcessInternalW(IN HANDLE hUserToken, IN LPCWSTR lpApplicationName, IN LPWSTR lpCommandLine, IN LPSECURITY_ATTRIBUTES lpProcessAttributes, IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN BOOL bInheritHandles, IN DWORD dwCreationFlags, IN LPVOID lpEnvironment, IN LPCWSTR lpCurrentDirectory, IN LPSTARTUPINFOW lpStartupInfo, IN LPPROCESS_INFORMATION lpProcessInformation, OUT PHANDLE hNewToken)
Definition: proc.c:2264
LPSTR lpTitle
Definition: winbase.h:799
LPWSTR lpReserved
Definition: winbase.h:818
WCHAR CurrentDirectory[1024]
Definition: chkdsk.c:74
VOID WINAPI BasepAnsiStringToHeapUnicodeString(IN LPCSTR AnsiString, OUT LPWSTR *UnicodeString)
Definition: utils.c:263
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:603
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
BOOLEAN WINAPI Basep8BitStringToDynamicUnicodeString(OUT PUNICODE_STRING UnicodeString, IN LPCSTR String)
Definition: utils.c:225
unsigned int BOOL
Definition: ntddk_ex.h:94
LPWSTR lpDesktop
Definition: winbase.h:819
smooth NULL
Definition: ftsmooth.c:416
LPWSTR lpTitle
Definition: winbase.h:820
void DPRINT(...)
Definition: polytest.cpp:61
LPSTR lpReserved
Definition: winbase.h:797
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
PVOID PVOID PWCHAR ApplicationName
Definition: env.c:45
LPSTR lpDesktop
Definition: winbase.h:798

Referenced by CreateProcessA().

◆ CreateProcessInternalW()

BOOL WINAPI CreateProcessInternalW ( IN HANDLE  hUserToken,
IN LPCWSTR  lpApplicationName,
IN LPWSTR  lpCommandLine,
IN LPSECURITY_ATTRIBUTES  lpProcessAttributes,
IN LPSECURITY_ATTRIBUTES  lpThreadAttributes,
IN BOOL  bInheritHandles,
IN DWORD  dwCreationFlags,
IN LPVOID  lpEnvironment,
IN LPCWSTR  lpCurrentDirectory,
IN LPSTARTUPINFOW  lpStartupInfo,
IN LPPROCESS_INFORMATION  lpProcessInformation,
OUT PHANDLE  hNewToken 
)

Definition at line 2264 of file proc.c.

2276 {
2277  //
2278  // Core variables used for creating the initial process and thread
2279  //
2280  SECURITY_ATTRIBUTES LocalThreadAttributes, LocalProcessAttributes;
2281  OBJECT_ATTRIBUTES LocalObjectAttributes;
2283  SECTION_IMAGE_INFORMATION ImageInformation;
2286  ULONG NoWindow, StackSize, ErrorCode, Flags;
2288  USHORT ImageMachine;
2289  ULONG ParameterFlags, PrivilegeValue, HardErrorMode, ErrorResponse;
2290  ULONG_PTR ErrorParameters[2];
2291  BOOLEAN InJob, SaferNeeded, UseLargePages, HavePrivilege;
2292  BOOLEAN QuerySection, SkipSaferAndAppCompat;
2293  CONTEXT Context;
2294  BASE_API_MESSAGE CsrMsg[2];
2295  PBASE_CREATE_PROCESS CreateProcessMsg;
2296  PCSR_CAPTURE_BUFFER CaptureBuffer;
2297  PVOID BaseAddress, PrivilegeState, RealTimePrivilegeState;
2298  HANDLE DebugHandle, TokenHandle, JobHandle, KeyHandle, ThreadHandle;
2299  HANDLE FileHandle, SectionHandle, ProcessHandle;
2301  PROCESS_PRIORITY_CLASS PriorityClass;
2302  NTSTATUS Status, AppCompatStatus, SaferStatus, IFEOStatus, ImageDbgStatus;
2303  PPEB Peb, RemotePeb;
2304  PTEB Teb;
2305  INITIAL_TEB InitialTeb;
2306  PVOID TibValue;
2307  PIMAGE_NT_HEADERS NtHeaders;
2308  STARTUPINFOW StartupInfo;
2309  PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
2310  UNICODE_STRING DebuggerString;
2311  BOOL Result;
2312  //
2313  // Variables used for command-line and argument parsing
2314  //
2315  PCHAR pcScan;
2316  SIZE_T n;
2317  WCHAR SaveChar;
2318  ULONG Length, FileAttribs, CmdQuoteLength;
2319  ULONG ResultSize;
2320  SIZE_T EnvironmentLength, CmdLineLength;
2321  PWCHAR QuotedCmdLine, AnsiCmdCommand, ExtBuffer, CurrentDirectory;
2322  PWCHAR NullBuffer, ScanString, NameBuffer, SearchPath, DebuggerCmdLine;
2323  ANSI_STRING AnsiEnv;
2324  UNICODE_STRING UnicodeEnv, PathName;
2325  BOOLEAN SearchRetry, QuotesNeeded, CmdLineIsAppName, HasQuotes;
2326 
2327  //
2328  // Variables used for Fusion/SxS (Side-by-Side Assemblies)
2329  //
2330  RTL_PATH_TYPE SxsPathType, PathType;
2331 #if _SXS_SUPPORT_ENABLED_
2332  PRTL_BUFFER ByteBuffer;
2333  PRTL_UNICODE_STRING_BUFFER ThisBuffer, Buffer, SxsStaticBuffers[5];
2334  PRTL_UNICODE_STRING_BUFFER* BufferHead, SxsStringBuffer;
2335  RTL_UNICODE_STRING_BUFFER SxsWin32ManifestPath, SxsNtManifestPath;
2336  RTL_UNICODE_STRING_BUFFER SxsWin32PolicyPath, SxsNtPolicyPath;
2337  RTL_UNICODE_STRING_BUFFER SxsWin32AssemblyDirectory;
2338  BASE_MSG_SXS_HANDLES MappedHandles, Handles, FileHandles;
2339  PVOID CapturedStrings[3];
2340  SXS_WIN32_NT_PATH_PAIR ExePathPair, ManifestPathPair, PolicyPathPair;
2341  SXS_OVERRIDE_MANIFEST OverrideManifest;
2342  UNICODE_STRING FreeString, SxsNtExePath;
2343  PWCHAR SxsConglomeratedBuffer, StaticBuffer;
2344  ULONG ConglomeratedBufferSizeBytes, StaticBufferSize, i;
2345 #endif
2347 
2348  //
2349  // Variables used for path conversion (and partially Fusion/SxS)
2350  //
2351  PWCHAR FilePart, PathBuffer, FreeBuffer;
2352  BOOLEAN TranslationStatus;
2353  RTL_RELATIVE_NAME_U SxsWin32RelativePath;
2354  UNICODE_STRING PathBufferString, SxsWin32ExePath;
2355 
2356  //
2357  // Variables used by Application Compatibility (and partially Fusion/SxS)
2358  //
2359  PVOID AppCompatSxsData, AppCompatData;
2360  ULONG AppCompatSxsDataSize, AppCompatDataSize;
2361  //
2362  // Variables used by VDM (Virtual Dos Machine) and WOW32 (16-bit Support)
2363  //
2364  ULONG BinarySubType, VdmBinaryType, VdmTask, VdmReserve;
2365  ULONG VdmUndoLevel;
2366  BOOLEAN UseVdmReserve;
2367  HANDLE VdmWaitObject;
2368  ANSI_STRING VdmAnsiEnv;
2369  UNICODE_STRING VdmString, VdmUnicodeEnv;
2370  BOOLEAN IsWowApp;
2371  PBASE_CHECK_VDM CheckVdmMsg;
2372 
2373  /* Zero out the initial core variables and handles */
2374  QuerySection = FALSE;
2375  InJob = FALSE;
2376  SkipSaferAndAppCompat = FALSE;
2377  ParameterFlags = 0;
2378  Flags = 0;
2379  DebugHandle = NULL;
2380  JobHandle = NULL;
2381  TokenHandle = NULL;
2382  FileHandle = NULL;
2383  SectionHandle = NULL;
2384  ProcessHandle = NULL;
2385  ThreadHandle = NULL;
2386  BaseAddress = (PVOID)1;
2387 
2388  /* Zero out initial SxS and Application Compatibility state */
2389  AppCompatData = NULL;
2390  AppCompatDataSize = 0;
2391  AppCompatSxsData = NULL;
2392  AppCompatSxsDataSize = 0;
2393  CaptureBuffer = NULL;
2394 #if _SXS_SUPPORT_ENABLED_
2395  SxsConglomeratedBuffer = NULL;
2396 #endif
2397  FusionFlags = 0;
2398 
2399  /* Zero out initial parsing variables -- others are initialized later */
2400  DebuggerCmdLine = NULL;
2401  PathBuffer = NULL;
2402  SearchPath = NULL;
2403  NullBuffer = NULL;
2404  FreeBuffer = NULL;
2405  NameBuffer = NULL;
2407  FilePart = NULL;
2408  DebuggerString.Buffer = NULL;
2409  HasQuotes = FALSE;
2410  QuotedCmdLine = NULL;
2411 
2412  /* Zero out initial VDM state */
2413  VdmAnsiEnv.Buffer = NULL;
2414  VdmUnicodeEnv.Buffer = NULL;
2415  VdmString.Buffer = NULL;
2416  VdmTask = 0;
2417  VdmUndoLevel = 0;
2418  VdmBinaryType = 0;
2419  VdmReserve = 0;
2420  VdmWaitObject = NULL;
2421  UseVdmReserve = FALSE;
2422  IsWowApp = FALSE;
2423 
2424  /* Set message structures */
2425  CreateProcessMsg = &CsrMsg[0].Data.CreateProcessRequest;
2426  CheckVdmMsg = &CsrMsg[1].Data.CheckVDMRequest;
2427 
2428  /* Clear the more complex structures by zeroing out their entire memory */
2429  RtlZeroMemory(&Context, sizeof(Context));
2430 #if _SXS_SUPPORT_ENABLED_
2431  RtlZeroMemory(&FileHandles, sizeof(FileHandles));
2432  RtlZeroMemory(&MappedHandles, sizeof(MappedHandles));
2433  RtlZeroMemory(&Handles, sizeof(Handles));
2434 #endif
2435  RtlZeroMemory(&CreateProcessMsg->Sxs, sizeof(CreateProcessMsg->Sxs));
2436  RtlZeroMemory(&LocalProcessAttributes, sizeof(LocalProcessAttributes));
2437  RtlZeroMemory(&LocalThreadAttributes, sizeof(LocalThreadAttributes));
2438 
2439  /* Zero out output arguments as well */
2440  RtlZeroMemory(lpProcessInformation, sizeof(*lpProcessInformation));
2441  if (hNewToken) *hNewToken = NULL;
2442 
2443  /* Capture the special window flag */
2444  NoWindow = dwCreationFlags & CREATE_NO_WINDOW;
2445  dwCreationFlags &= ~CREATE_NO_WINDOW;
2446 
2447 #if _SXS_SUPPORT_ENABLED_
2448  /* Setup the SxS static string arrays and buffers */
2449  SxsStaticBuffers[0] = &SxsWin32ManifestPath;
2450  SxsStaticBuffers[1] = &SxsWin32PolicyPath;
2451  SxsStaticBuffers[2] = &SxsWin32AssemblyDirectory;
2452  SxsStaticBuffers[3] = &SxsNtManifestPath;
2453  SxsStaticBuffers[4] = &SxsNtPolicyPath;
2454  ExePathPair.Win32 = &SxsWin32ExePath;
2455  ExePathPair.Nt = &SxsNtExePath;
2456  ManifestPathPair.Win32 = &SxsWin32ManifestPath.String;
2457  ManifestPathPair.Nt = &SxsNtManifestPath.String;
2458  PolicyPathPair.Win32 = &SxsWin32PolicyPath.String;
2459  PolicyPathPair.Nt = &SxsNtPolicyPath.String;
2460 #endif
2461 
2462  DPRINT("CreateProcessInternalW: '%S' '%S' %lx\n", lpApplicationName, lpCommandLine, dwCreationFlags);
2463 
2464  /* Finally, set our TEB and PEB */
2465  Teb = NtCurrentTeb();
2466  Peb = NtCurrentPeb();
2467 
2468  /* This combination is illegal (see MSDN) */
2469  if ((dwCreationFlags & (DETACHED_PROCESS | CREATE_NEW_CONSOLE)) ==
2471  {
2472  DPRINT1("Invalid flag combo used\n");
2474  return FALSE;
2475  }
2476 
2477  /* Convert the priority class */
2478  if (dwCreationFlags & IDLE_PRIORITY_CLASS)
2479  {
2481  }
2482  else if (dwCreationFlags & BELOW_NORMAL_PRIORITY_CLASS)
2483  {
2485  }
2486  else if (dwCreationFlags & NORMAL_PRIORITY_CLASS)
2487  {
2489  }
2490  else if (dwCreationFlags & ABOVE_NORMAL_PRIORITY_CLASS)
2491  {
2493  }
2494  else if (dwCreationFlags & HIGH_PRIORITY_CLASS)
2495  {
2497  }
2498  else if (dwCreationFlags & REALTIME_PRIORITY_CLASS)
2499  {
2501  PriorityClass.PriorityClass += (BasepIsRealtimeAllowed(FALSE) != NULL);
2502  }
2503  else
2504  {
2506  }
2507 
2508  /* Done with the priority masks, so get rid of them */
2509  PriorityClass.Foreground = FALSE;
2510  dwCreationFlags &= ~(NORMAL_PRIORITY_CLASS |
2516 
2517  /* You cannot request both a shared and a separate WoW VDM */
2518  if ((dwCreationFlags & CREATE_SEPARATE_WOW_VDM) &&
2519  (dwCreationFlags & CREATE_SHARED_WOW_VDM))
2520  {
2521  /* Fail such nonsensical attempts */
2522  DPRINT1("Invalid WOW flags\n");
2524  return FALSE;
2525  }
2526  else if (!(dwCreationFlags & CREATE_SHARED_WOW_VDM) &&
2528  {
2529  /* A shared WoW VDM was not requested but system enforces separation */
2530  dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
2531  }
2532 
2533  /* If a shared WoW VDM is used, make sure the process isn't in a job */
2534  if (!(dwCreationFlags & CREATE_SEPARATE_WOW_VDM) &&
2536  {
2537  /* Remove the shared flag and add the separate flag */
2538  dwCreationFlags = (dwCreationFlags &~ CREATE_SHARED_WOW_VDM) |
2540  }
2541 
2542  /* Convert the environment */
2543  if ((lpEnvironment) && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT))
2544  {
2545  /* Scan the environment to calculate its Unicode size */
2546  AnsiEnv.Buffer = pcScan = (PCHAR)lpEnvironment;
2547  while ((*pcScan) || (*(pcScan + 1))) ++pcScan;
2548 
2549  /* Make sure the environment is not too large */
2550  EnvironmentLength = (pcScan + sizeof(ANSI_NULL) - (PCHAR)lpEnvironment);
2551  if (EnvironmentLength > MAXUSHORT)
2552  {
2553  /* Fail */
2555  return FALSE;
2556  }
2557 
2558  /* Create our ANSI String */
2559  AnsiEnv.Length = (USHORT)EnvironmentLength;
2560  AnsiEnv.MaximumLength = AnsiEnv.Length + sizeof(ANSI_NULL);
2561 
2562  /* Allocate memory for the Unicode Environment */
2563  UnicodeEnv.Buffer = NULL;
2564  RegionSize = AnsiEnv.MaximumLength * sizeof(WCHAR);
2566  (PVOID)&UnicodeEnv.Buffer,
2567  0,
2568  &RegionSize,
2569  MEM_COMMIT,
2570  PAGE_READWRITE);
2571  if (!NT_SUCCESS(Status))
2572  {
2573  /* Fail */
2575  return FALSE;
2576  }
2577 
2578  /* Use the allocated size and convert */
2579  UnicodeEnv.MaximumLength = (USHORT)RegionSize;
2580  Status = RtlAnsiStringToUnicodeString(&UnicodeEnv, &AnsiEnv, FALSE);
2581  if (!NT_SUCCESS(Status))
2582  {
2583  /* Fail */
2585  (PVOID)&UnicodeEnv.Buffer,
2586  &RegionSize,
2587  MEM_RELEASE);
2589  return FALSE;
2590  }
2591 
2592  /* Now set the Unicode environment as the environment string pointer */
2593  lpEnvironment = UnicodeEnv.Buffer;
2594  }
2595 
2596  /* Make a copy of the caller's startup info since we'll modify it */
2597  StartupInfo = *lpStartupInfo;
2598 
2599  /* Check if private data is being sent on the same channel as std handles */
2600  if ((StartupInfo.dwFlags & STARTF_USESTDHANDLES) &&
2601  (StartupInfo.dwFlags & (STARTF_USEHOTKEY | STARTF_SHELLPRIVATE)))
2602  {
2603  /* Cannot use the std handles since we have monitor/hotkey values */
2604  StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
2605  }
2606 
2607  /* If there's a debugger, or we have to launch cmd.exe, we go back here */
2608 AppNameRetry:
2609  /* New iteration -- free any existing name buffer */
2610  if (NameBuffer)
2611  {
2612  RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
2613  NameBuffer = NULL;
2614  }
2615 
2616  /* New iteration -- free any existing free buffer */
2617  if (FreeBuffer)
2618  {
2619  RtlFreeHeap(RtlGetProcessHeap(), 0, FreeBuffer);
2620  FreeBuffer = NULL;
2621  }
2622 
2623  /* New iteration -- close any existing file handle */
2624  if (FileHandle)
2625  {
2627  FileHandle = NULL;
2628  }
2629 
2630  /* Set the initial parsing state. This code can loop -- don't move this! */
2631  ErrorCode = 0;
2632  SearchRetry = TRUE;
2633  QuotesNeeded = FALSE;
2634  CmdLineIsAppName = FALSE;
2635 
2636  /* First check if we don't have an application name */
2637  if (!lpApplicationName)
2638  {
2639  /* This should be the first time we attempt creating one */
2640  ASSERT(NameBuffer == NULL);
2641 
2642  /* Allocate a buffer to hold it */
2643  NameBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
2644  0,
2645  MAX_PATH * sizeof(WCHAR));
2646  if (!NameBuffer)
2647  {
2649  Result = FALSE;
2650  goto Quickie;
2651  }
2652 
2653  /* Initialize the application name and our parsing parameters */
2654  lpApplicationName = NullBuffer = ScanString = lpCommandLine;
2655 
2656  /* Check for an initial quote*/
2657  if (*lpCommandLine == L'\"')
2658  {
2659  /* We found a quote, keep searching for another one */
2660  SearchRetry = FALSE;
2661  ScanString++;
2662  lpApplicationName = ScanString;
2663  while (*ScanString)
2664  {
2665  /* Have we found the terminating quote? */
2666  if (*ScanString == L'\"')
2667  {
2668  /* We're done, get out of here */
2669  NullBuffer = ScanString;
2670  HasQuotes = TRUE;
2671  break;
2672  }
2673 
2674  /* Keep searching for the quote */
2675  ScanString++;
2676  NullBuffer = ScanString;
2677  }
2678  }
2679  else
2680  {
2681 StartScan:
2682  /* We simply make the application name be the command line*/
2683  lpApplicationName = lpCommandLine;
2684  while (*ScanString)
2685  {
2686  /* Check if it starts with a space or tab */
2687  if ((*ScanString == L' ') || (*ScanString == L'\t'))
2688  {
2689  /* Break out of the search loop */
2690  NullBuffer = ScanString;
2691  break;
2692  }
2693 
2694  /* Keep searching for a space or tab */
2695  ScanString++;
2696  NullBuffer = ScanString;
2697  }
2698  }
2699 
2700  /* We have found the end of the application name, terminate it */
2701  SaveChar = *NullBuffer;
2702  *NullBuffer = UNICODE_NULL;
2703 
2704  /* New iteration -- free any existing saved path */
2705  if (SearchPath)
2706  {
2707  RtlFreeHeap(RtlGetProcessHeap(), 0, SearchPath);
2708  SearchPath = NULL;
2709  }
2710 
2711  /* Now compute the final EXE path based on the name */
2712  SearchPath = BaseComputeProcessExePath((LPWSTR)lpApplicationName);
2713  DPRINT("Search Path: %S\n", SearchPath);
2714  if (!SearchPath)
2715  {
2717  Result = FALSE;
2718  goto Quickie;
2719  }
2720 
2721  /* And search for the executable in the search path */
2723  lpApplicationName,
2724  L".exe",
2725  MAX_PATH,
2726  NameBuffer,
2727  NULL);
2728 
2729  /* Did we find it? */
2730  if ((Length) && (Length < MAX_PATH))
2731  {
2732  /* Get file attributes */
2733  FileAttribs = GetFileAttributesW(NameBuffer);
2734  if ((FileAttribs != INVALID_FILE_ATTRIBUTES) &&
2735  (FileAttribs & FILE_ATTRIBUTE_DIRECTORY))
2736  {
2737  /* This was a directory, fail later on */
2738  Length = 0;
2739  }
2740  else
2741  {
2742  /* It's a file! */
2743  Length++;
2744  }
2745  }
2746 
2747  DPRINT("Length: %lu Buffer: %S\n", Length, NameBuffer);
2748 
2749  /* Check if there was a failure in SearchPathW */
2750  if ((Length) && (Length < MAX_PATH))
2751  {
2752  /* Everything looks good, restore the name */
2753  *NullBuffer = SaveChar;
2754  lpApplicationName = NameBuffer;
2755  }
2756  else
2757  {
2758  /* Check if this was a relative path, which would explain it */
2759  PathType = RtlDetermineDosPathNameType_U(lpApplicationName);
2761  {
2762  /* This should fail, and give us a detailed LastError */
2763  FileHandle = CreateFileW(lpApplicationName,
2764  GENERIC_READ,
2765  FILE_SHARE_READ |
2767  NULL,
2768  OPEN_EXISTING,
2770  NULL);
2772  {
2773  /* It worked? Return a generic error */
2775  FileHandle = NULL;
2777  }
2778  }
2779  else
2780  {
2781  /* Path was absolute, which means it doesn't exist */
2783  }
2784 
2785  /* Did we already fail once? */
2786  if (ErrorCode)
2787  {
2788  /* Set the error code */
2790  }
2791  else
2792  {
2793  /* Not yet, cache it */
2794  ErrorCode = GetLastError();
2795  }
2796 
2797  /* Put back the command line */
2798  *NullBuffer = SaveChar;
2799  lpApplicationName = NameBuffer;
2800 
2801  /* It's possible there's whitespace in the directory name */
2802  if (!(*ScanString) || !(SearchRetry))
2803  {
2804  /* Not the case, give up completely */
2805  Result = FALSE;
2806  goto Quickie;
2807  }
2808 
2809  /* There are spaces, so keep trying the next possibility */
2810  ScanString++;
2811  NullBuffer = ScanString;
2812 
2813  /* We will have to add a quote, since there is a space */
2814  QuotesNeeded = TRUE;
2815  HasQuotes = TRUE;
2816  goto StartScan;
2817  }
2818  }
2819  else if (!(lpCommandLine) || !(*lpCommandLine))
2820  {
2821  /* We don't have a command line, so just use the application name */
2822  CmdLineIsAppName = TRUE;
2823  lpCommandLine = (LPWSTR)lpApplicationName;
2824  }
2825 
2826  /* Convert the application name to its NT path */
2827  TranslationStatus = RtlDosPathNameToRelativeNtPathName_U(lpApplicationName,
2828  &PathName,
2829  NULL,
2830  &SxsWin32RelativePath);
2831  if (!TranslationStatus)
2832  {
2833  /* Path must be invalid somehow, bail out */
2834  DPRINT1("Path translation for SxS failed\n");
2836  Result = FALSE;
2837  goto Quickie;
2838  }
2839 
2840  /* Setup the buffer that needs to be freed at the end */
2841  ASSERT(FreeBuffer == NULL);
2842  FreeBuffer = PathName.Buffer;
2843 
2844  /* Check what kind of path the application is, for SxS (Fusion) purposes */
2845  RtlInitUnicodeString(&SxsWin32ExePath, lpApplicationName);
2846  SxsPathType = RtlDetermineDosPathNameType_U(lpApplicationName);
2847  if ((SxsPathType != RtlPathTypeDriveAbsolute) &&
2848  (SxsPathType != RtlPathTypeLocalDevice) &&
2849  (SxsPathType != RtlPathTypeRootLocalDevice) &&
2850  (SxsPathType != RtlPathTypeUncAbsolute))
2851  {
2852  /* Relative-type path, get the full path */
2853  RtlInitEmptyUnicodeString(&PathBufferString, NULL, 0);
2854  Status = RtlGetFullPathName_UstrEx(&SxsWin32ExePath,
2855  NULL,
2856  &PathBufferString,
2857  NULL,
2858  NULL,
2859  NULL,
2860  &SxsPathType,
2861  NULL);
2862  if (!NT_SUCCESS(Status))
2863  {
2864  /* Fail the rest of the create */
2865  RtlReleaseRelativeName(&SxsWin32RelativePath);
2867  Result = FALSE;
2868  goto Quickie;
2869  }
2870 
2871  /* Use this full path as the SxS path */
2872  SxsWin32ExePath = PathBufferString;
2873  PathBuffer = PathBufferString.Buffer;
2874  PathBufferString.Buffer = NULL;
2875  DPRINT("SxS Path: %S\n", PathBuffer);
2876  }
2877 
2878  /* Also set the .EXE path based on the path name */
2879 #if _SXS_SUPPORT_ENABLED_
2880  SxsNtExePath = PathName;
2881 #endif
2882  if (SxsWin32RelativePath.RelativeName.Length)
2883  {
2884  /* If it's relative, capture the relative name */
2885  PathName = SxsWin32RelativePath.RelativeName;
2886  }
2887  else
2888  {
2889  /* Otherwise, it's absolute, make sure no relative dir is used */
2890  SxsWin32RelativePath.ContainingDirectory = NULL;
2891  }
2892 
2893  /* Now use the path name, and the root path, to try opening the app */
2894  DPRINT("Path: %wZ. Dir: %p\n", &PathName, SxsWin32RelativePath.ContainingDirectory);
2895  InitializeObjectAttributes(&LocalObjectAttributes,
2896  &PathName,
2898  SxsWin32RelativePath.ContainingDirectory,
2899  NULL);
2901  SYNCHRONIZE |
2903  FILE_READ_DATA |
2904  FILE_EXECUTE,
2905  &LocalObjectAttributes,
2906  &IoStatusBlock,
2910  if (!NT_SUCCESS(Status))
2911  {
2912  /* Try to open the app just for execute purposes instead */
2915  &LocalObjectAttributes,
2916  &IoStatusBlock,
2920  }
2921 
2922  /* Failure path, display which file failed to open */
2923  if (!NT_SUCCESS(Status))
2924  DPRINT1("Open file failed: %lx (%wZ)\n", Status, &PathName);
2925 
2926  /* Cleanup in preparation for failure or success */
2927  RtlReleaseRelativeName(&SxsWin32RelativePath);
2928 
2929  if (!NT_SUCCESS(Status))
2930  {
2931  /* Failure path, try to understand why */
2932  if (RtlIsDosDeviceName_U(lpApplicationName))
2933  {
2934  /* If a device is being executed, return this special error code */
2936  Result = FALSE;
2937  goto Quickie;
2938  }
2939  else
2940  {
2941  /* Otherwise return the converted NT error code */
2943  Result = FALSE;
2944  goto Quickie;
2945  }
2946  }
2947 
2948  /* Did the caller specify a desktop? */
2949  if (!StartupInfo.lpDesktop)
2950  {
2951  /* Use the one from the current process */
2953  }
2954 
2955  /* Create a section for this file */
2956  Status = NtCreateSection(&SectionHandle,
2958  NULL,
2959  NULL,
2960  PAGE_EXECUTE,
2961  SEC_IMAGE,
2962  FileHandle);
2963  DPRINT("Section status: %lx\n", Status);
2964  if (NT_SUCCESS(Status))
2965  {
2966  /* Are we running on Windows Embedded, Datacenter, Blade or Starter? */
2967  if (SharedUserData->SuiteMask & (VER_SUITE_EMBEDDEDNT |
2970  VER_SUITE_BLADE))
2971  {
2972  /* These SKUs do not allow running certain applications */
2975  {
2976  /* And this is one of them! */
2977  DPRINT1("Invalid Blade hashes!\n");
2979  Result = FALSE;
2980  goto Quickie;
2981  }
2982 
2983  /* Did we get some other failure? */
2984  if (!NT_SUCCESS(Status))
2985  {
2986  /* If we couldn't check the hashes, assume nefariousness */
2987  DPRINT1("Tampered Blade hashes!\n");
2989  Result = FALSE;
2990  goto Quickie;
2991  }
2992  }
2993 
2994  /* Now do Winsafer, etc, checks */
2995  Status = BasepIsProcessAllowed((LPWSTR)lpApplicationName);
2996  if (!NT_SUCCESS(Status))
2997  {
2998  /* Fail if we're not allowed to launch the process */
2999  DPRINT1("Process not allowed to launch: %lx\n", Status);
3001  if (SectionHandle)
3002  {
3003  NtClose(SectionHandle);
3004  SectionHandle = NULL;
3005  }
3006  Result = FALSE;
3007  goto Quickie;
3008  }
3009 
3010  /* Is a DOS VDM being forced, but we already have a WOW32 instance ready? */
3011  if ((dwCreationFlags & CREATE_FORCEDOS) &&
3013  {
3014  /* This request can't be satisfied, instead, a separate VDM is needed */
3015  dwCreationFlags &= ~(CREATE_FORCEDOS | CREATE_SHARED_WOW_VDM);
3016  dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
3017 
3018  /* Set a failure code, ask for VDM reservation */
3020  UseVdmReserve = TRUE;
3021 
3022  /* Close the current handle */
3023  NtClose(SectionHandle);
3024  SectionHandle = NULL;
3025 
3026  /* Don't query the section later */
3027  QuerySection = FALSE;
3028  }
3029  }
3030 
3031  /* Did we already do these checks? */
3032  if (!SkipSaferAndAppCompat)
3033  {
3034  /* Is everything OK so far, OR do we have an non-MZ, non-DOS app? */
3035  if ((NT_SUCCESS(Status)) ||
3037  !(BaseIsDosApplication(&PathName, Status))))
3038  {
3039  /* Clear the machine type in case of failure */
3040  ImageMachine = 0;
3041 
3042  /* Clean any app compat data that may have accumulated */
3043  BasepFreeAppCompatData(AppCompatData, AppCompatSxsData);
3044  AppCompatData = NULL;
3045  AppCompatSxsData = NULL;
3046 
3047  /* Do we have a section? */
3048  if (SectionHandle)
3049  {
3050  /* Have we already queried it? */
3051  if (QuerySection)
3052  {
3053  /* Nothing to do */
3054  AppCompatStatus = STATUS_SUCCESS;
3055  }
3056  else
3057  {
3058  /* Get some information about the executable */
3059  AppCompatStatus = NtQuerySection(SectionHandle,
3061  &ImageInformation,
3062  sizeof(ImageInformation),
3063  NULL);
3064  }
3065 
3066  /* Do we have section information now? */
3067  if (NT_SUCCESS(AppCompatStatus))
3068  {
3069  /* Don't ask for it again, save the machine type */
3070  QuerySection = TRUE;
3071  ImageMachine = ImageInformation.Machine;
3072  }
3073  }
3074 
3075  /* Is there a reason/Shim we shouldn't run this application? */
3076  AppCompatStatus = BasepCheckBadapp(FileHandle,
3077  FreeBuffer,
3078  lpEnvironment,
3079  ImageMachine,
3080  &AppCompatData,
3081  &AppCompatDataSize,
3082  &AppCompatSxsData,
3083  &AppCompatSxsDataSize,
3084  &FusionFlags);
3085  if (!NT_SUCCESS(AppCompatStatus))
3086  {
3087  /* This is usually the status we get back */
3088  DPRINT1("App compat launch failure: %lx\n", AppCompatStatus);
3089  if (AppCompatStatus == STATUS_ACCESS_DENIED)
3090  {
3091  /* Convert it to something more Win32-specific */
3093  }
3094  else
3095  {
3096  /* Some other error */
3097  BaseSetLastNTError(AppCompatStatus);
3098  }
3099 
3100  /* Did we have a section? */
3101  if (SectionHandle)
3102  {
3103  /* Clean it up */
3104  NtClose(SectionHandle);
3105  SectionHandle = NULL;
3106  }
3107 
3108  /* Fail the call */
3109  Result = FALSE;
3110  goto Quickie;
3111  }
3112  }
3113  }
3114 
3115  //ASSERT((dwFusionFlags & ~SXS_APPCOMPACT_FLAG_APP_RUNNING_SAFEMODE) == 0);
3116 
3117  /* Have we already done, and do we need to do, SRP (WinSafer) checks? */
3118  if (!(SkipSaferAndAppCompat) &&
3119  ~(dwCreationFlags & CREATE_PRESERVE_CODE_AUTHZ_LEVEL))
3120  {
3121  /* Assume yes */
3122  SaferNeeded = TRUE;
3123  switch (Status)
3124  {
3129  /* For all DOS, 16-bit, OS/2 images, we do*/
3130  break;
3131 
3133  /* For invalid files, we don't, unless it's a .BAT file */
3134  if (BaseIsDosApplication(&PathName, Status)) break;
3135 
3136  default:
3137  /* Any other error codes we also don't */
3138  if (!NT_SUCCESS(Status))
3139  {
3140  SaferNeeded = FALSE;
3141  }
3142 
3143  /* But for success, we do */
3144  break;
3145  }
3146 
3147  /* Okay, so what did the checks above result in? */
3148  if (SaferNeeded)
3149  {
3150  /* We have to call into the WinSafer library and actually check */
3152  (LPWSTR)lpApplicationName,
3153  FileHandle,
3154  &InJob,
3155  &TokenHandle,
3156  &JobHandle);
3157  if (SaferStatus == 0xFFFFFFFF)
3158  {
3159  /* Back in 2003, they didn't have an NTSTATUS for this... */
3160  DPRINT1("WinSafer blocking process launch\n");
3162  Result = FALSE;
3163  goto Quickie;
3164  }
3165 
3166  /* Other status codes are not-Safer related, just convert them */
3167  if (!NT_SUCCESS(SaferStatus))
3168  {
3169  DPRINT1("Error checking WinSafer: %lx\n", SaferStatus);
3170  BaseSetLastNTError(SaferStatus);
3171  Result = FALSE;
3172  goto Quickie;
3173  }
3174  }
3175  }
3176 
3177  /* The last step is to figure out why the section object was not created */
3178  switch (Status)
3179  {
3181  {
3182  /* 16-bit binary. Should we use WOW or does the caller force VDM? */
3183  if (!(dwCreationFlags & CREATE_FORCEDOS))
3184  {
3185  /* Remember that we're launching WOW */
3186  IsWowApp = TRUE;
3187 
3188  /* Create the VDM environment, it's valid for WOW too */
3189  Result = BaseCreateVDMEnvironment(lpEnvironment,
3190  &VdmAnsiEnv,
3191  &VdmUnicodeEnv);
3192  if (!Result)
3193  {
3194  DPRINT1("VDM environment for WOW app failed\n");
3195  goto Quickie;
3196  }
3197 
3198  /* We're going to try this twice, so do a loop */
3199  while (TRUE)
3200  {
3201  /* Pick which kind of WOW mode we want to run in */
3202  VdmBinaryType = (dwCreationFlags &
3205 
3206  /* Get all the VDM settings and current status */
3207  Status = BaseCheckVDM(VdmBinaryType,
3208  lpApplicationName,
3209  lpCommandLine,
3210  lpCurrentDirectory,
3211  &VdmAnsiEnv,
3212  &CsrMsg[1],
3213  &VdmTask,
3214  dwCreationFlags,
3215  &StartupInfo,
3216  hUserToken);
3217 
3218  /* If it worked, no need to try again */
3219  if (NT_SUCCESS(Status)) break;
3220 
3221  /* Check if it's disallowed or if it's our second time */
3223  if ((Status == STATUS_VDM_DISALLOWED) ||
3224  (VdmBinaryType == BINARY_TYPE_SEPARATE_WOW) ||
3226  {
3227  /* Fail the call -- we won't try again */
3228  DPRINT1("VDM message failure for WOW: %lx\n", Status);
3229  Result = FALSE;
3230  goto Quickie;
3231  }
3232 
3233  /* Try one more time, but with a separate WOW instance */
3234  dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
3235  }
3236 
3237  /* Check which VDM state we're currently in */
3238  switch (CheckVdmMsg->VDMState & (VDM_NOT_LOADED |
3239  VDM_NOT_READY |
3240  VDM_READY))
3241  {
3242  case VDM_NOT_LOADED:
3243  /* VDM is not fully loaded, so not that much to undo */
3244  VdmUndoLevel = VDM_UNDO_PARTIAL;
3245 
3246  /* Reset VDM reserve if needed */
3247  if (UseVdmReserve) VdmReserve = 1;
3248 
3249  /* Get the required parameters and names for launch */
3250  Result = BaseGetVdmConfigInfo(lpCommandLine,
3251  VdmTask,
3252  VdmBinaryType,
3253  &VdmString,
3254  &VdmReserve);
3255  if (!Result)
3256  {
3257  DPRINT1("VDM Configuration failed for WOW\n");
3259  goto Quickie;
3260  }
3261 
3262  /* Update the command-line with the VDM one instead */
3263  lpCommandLine = VdmString.Buffer;
3264  lpApplicationName = NULL;
3265 
3266  /* We don't want a console, detachment, nor a window */
3267  dwCreationFlags |= CREATE_NO_WINDOW;
3268  dwCreationFlags &= ~(CREATE_NEW_CONSOLE | DETACHED_PROCESS);
3269 
3270  /* Force feedback on */
3271  StartupInfo.dwFlags |= STARTF_FORCEONFEEDBACK;
3272  break;
3273 
3274 
3275  case VDM_READY:
3276  /* VDM is ready, so we have to undo everything */
3277  VdmUndoLevel = VDM_UNDO_REUSE;
3278 
3279  /* Check if CSRSS wants us to wait on VDM */
3280  VdmWaitObject = CheckVdmMsg->WaitObjectForParent;
3281  break;
3282 
3283  case VDM_NOT_READY:
3284  /* Something is wrong with VDM, we'll fail the call */
3285  DPRINT1("VDM is not ready for WOW\n");
3287  Result = FALSE;
3288  goto Quickie;
3289 
3290  default:
3291  break;
3292  }
3293 
3294  /* Since to get NULL, we allocate from 0x1, account for this */
3295  VdmReserve--;
3296 
3297  /* This implies VDM is ready, so skip everything else */
3298  if (VdmWaitObject) goto VdmShortCircuit;
3299 
3300  /* Don't inherit handles since we're doing VDM now */
3301  bInheritHandles = FALSE;
3302 
3303  /* Had the user passed in environment? If so, destroy it */
3304  if ((lpEnvironment) &&
3305  !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT))
3306  {
3307  RtlDestroyEnvironment(lpEnvironment);
3308  }
3309 
3310  /* We've already done all these checks, don't do them again */
3311  SkipSaferAndAppCompat = TRUE;
3312  goto AppNameRetry;
3313  }
3314 
3315  // There is no break here on purpose, so FORCEDOS drops down!
3316  }
3317 
3321  {
3322  /* We're launching an executable application */
3323  BinarySubType = BINARY_TYPE_EXE;
3324 
3325  /* We can drop here from other "cases" above too, so check */
3328  (BinarySubType = BaseIsDosApplication(&PathName, Status)))
3329  {
3330  /* We're launching a DOS application */
3331  VdmBinaryType = BINARY_TYPE_DOS;
3332 
3333  /* Based on the caller environment, create a VDM one */
3334  Result = BaseCreateVDMEnvironment(lpEnvironment,
3335  &VdmAnsiEnv,
3336  &VdmUnicodeEnv);
3337  if (!Result)
3338  {
3339  DPRINT1("VDM environment for DOS failed\n");
3340  goto Quickie;
3341  }
3342 
3343  /* Check the current state of the VDM subsystem */
3344  Status = BaseCheckVDM(VdmBinaryType | BinarySubType,
3345  lpApplicationName,
3346  lpCommandLine,
3347  lpCurrentDirectory,
3348  &VdmAnsiEnv,
3349  &CsrMsg[1],
3350  &VdmTask,
3351  dwCreationFlags,
3352  &StartupInfo,
3353  NULL);
3354  if (!NT_SUCCESS(Status))
3355  {
3356  /* Failed to inquire about VDM, fail the call */
3357  DPRINT1("VDM message failure for DOS: %lx\n", Status);
3359  Result = FALSE;
3360  goto Quickie;
3361  };
3362 
3363  /* Handle possible VDM states */
3364  switch (CheckVdmMsg->VDMState & (VDM_NOT_LOADED |
3365  VDM_NOT_READY |
3366  VDM_READY))
3367  {
3368  case VDM_NOT_LOADED:
3369  /* If VDM is not loaded, we'll do a partial undo */
3370  VdmUndoLevel = VDM_UNDO_PARTIAL;
3371 
3372  /* A VDM process can't also be detached, so fail */
3373  if (dwCreationFlags & DETACHED_PROCESS)
3374  {
3375  DPRINT1("Detached process but no VDM, not allowed\n");
3377  return FALSE;
3378  }
3379 
3380  /* Get the required parameters and names for launch */
3381  Result = BaseGetVdmConfigInfo(lpCommandLine,
3382  VdmTask,
3383  VdmBinaryType,
3384  &VdmString,
3385  &VdmReserve);
3386  if (!Result)
3387  {
3388  DPRINT1("VDM Configuration failed for DOS\n");
3390  goto Quickie;
3391  }
3392 
3393  /* Update the command-line to launch VDM instead */
3394  lpCommandLine = VdmString.Buffer;
3395  lpApplicationName = NULL;
3396  break;
3397 
3398  case VDM_READY:
3399  /* VDM is ready, so we have to undo everything */
3400  VdmUndoLevel = VDM_UNDO_REUSE;
3401 
3402  /* Check if CSRSS wants us to wait on VDM */
3403  VdmWaitObject = CheckVdmMsg->WaitObjectForParent;
3404  break;
3405 
3406  case VDM_NOT_READY:
3407  /* Something is wrong with VDM, we'll fail the call */
3408  DPRINT1("VDM is not ready for DOS\n");
3410  Result = FALSE;
3411  goto Quickie;
3412 
3413  default:
3414  break;
3415  }
3416 
3417  /* Since to get NULL, we allocate from 0x1, account for this */
3418  VdmReserve--;
3419 
3420  /* This implies VDM is ready, so skip everything else */
3421  if (VdmWaitObject) goto VdmShortCircuit;
3422 
3423  /* Don't inherit handles since we're doing VDM now */
3424  bInheritHandles = FALSE;
3425 
3426  /* Had the user passed in environment? If so, destroy it */
3427  if ((lpEnvironment) &&
3428  !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT))
3429  {
3430  RtlDestroyEnvironment(lpEnvironment);
3431  }
3432 
3433  /* Use our VDM Unicode environment instead */
3434  lpEnvironment = VdmUnicodeEnv.Buffer;
3435  }
3436  else
3437  {
3438  /* It's a batch file, get the extension */
3439  ExtBuffer = &PathName.Buffer[PathName.Length / sizeof(WCHAR) - 4];
3440 
3441  /* Make sure the extensions are correct */
3442  if ((PathName.Length < (4 * sizeof(WCHAR))) ||
3443  ((_wcsnicmp(ExtBuffer, L".bat", 4)) &&
3444  (_wcsnicmp(ExtBuffer, L".cmd", 4))))
3445  {
3446  DPRINT1("'%wZ': Invalid EXE, and not a batch or script file\n", &PathName);
3448  Result = FALSE;
3449  goto Quickie;
3450  }
3451 
3452  /* Check if we need to account for quotes around the path */
3453  CmdQuoteLength = CmdLineIsAppName || HasQuotes;
3454  if (!CmdLineIsAppName)
3455  {
3456  if (HasQuotes) CmdQuoteLength++;
3457  }
3458  else
3459  {
3460  CmdQuoteLength++;
3461  }
3462 
3463  /* Calculate the length of the command line */
3464  CmdLineLength = wcslen(lpCommandLine);
3465  CmdLineLength += wcslen(CMD_STRING);
3466  CmdLineLength += CmdQuoteLength + sizeof(ANSI_NULL);
3467  CmdLineLength *= sizeof(WCHAR);
3468 
3469  /* Allocate space for the new command line */
3470  AnsiCmdCommand = RtlAllocateHeap(RtlGetProcessHeap(),
3471  0,
3472  CmdLineLength);
3473  if (!AnsiCmdCommand)
3474  {
3476  Result = FALSE;
3477  goto Quickie;
3478  }
3479 
3480  /* Build it */
3481  wcscpy(AnsiCmdCommand, CMD_STRING);
3482  if ((CmdLineIsAppName) || (HasQuotes))
3483  {
3484  wcscat(AnsiCmdCommand, L"\"");
3485  }
3486  wcscat(AnsiCmdCommand, lpCommandLine);
3487  if ((CmdLineIsAppName) || (HasQuotes))
3488  {
3489  wcscat(AnsiCmdCommand, L"\"");
3490  }
3491 
3492  /* Create it as a Unicode String */
3493  RtlInitUnicodeString(&DebuggerString, AnsiCmdCommand);
3494 
3495  /* Set the command line to this */
3496  lpCommandLine = DebuggerString.Buffer;
3497  lpApplicationName = NULL;
3498  DPRINT1("Retrying with: %S\n", lpCommandLine);
3499  }
3500 
3501  /* We've already done all these checks, don't do them again */
3502  SkipSaferAndAppCompat = TRUE;
3503  goto AppNameRetry;
3504  }
3505 
3507  {
3508  /* 64-bit binaries are not allowed to run on 32-bit ReactOS */
3509  DPRINT1("64-bit binary, failing\n");
3511  Result = FALSE;
3512  goto Quickie;
3513  }
3514 
3516  {
3517  /* Set the correct last error for this */
3518  DPRINT1("File is offline, failing\n");
3520  break;
3521  }
3522 
3523  default:
3524  {
3525  /* Any other error, convert it to a generic Win32 error */
3526  if (!NT_SUCCESS(Status))
3527  {
3528  DPRINT1("Failed to create section: %lx\n", Status);
3530  Result = FALSE;
3531  goto Quickie;
3532  }
3533 
3534  /* Otherwise, this must be success */
3536  break;
3537  }
3538  }
3539 
3540  /* Is this not a WOW application, but a WOW32 VDM was requested for it? */
3541  if (!(IsWowApp) && (dwCreationFlags & CREATE_SEPARATE_WOW_VDM))
3542  {
3543  /* Ignore the nonsensical request */
3544  dwCreationFlags &= ~CREATE_SEPARATE_WOW_VDM;
3545  }
3546 
3547  /* Did we already check information for the section? */
3548  if (!QuerySection)
3549  {
3550  /* Get some information about the executable */
3551  Status = NtQuerySection(SectionHandle,
3553  &ImageInformation,
3554  sizeof(ImageInformation),
3555  NULL);
3556  if (!NT_SUCCESS(Status))
3557  {
3558  /* We failed, bail out */
3559  DPRINT1("Section query failed\n");
3561  Result = FALSE;
3562  goto Quickie;
3563  }
3564 
3565  /* Don't check this later */
3566  QuerySection = TRUE;
3567  }
3568 
3569  /* Check if this was linked as a DLL */
3570  if (ImageInformation.ImageCharacteristics & IMAGE_FILE_DLL)
3571  {
3572  /* These aren't valid images to try to execute! */
3573  DPRINT1("Trying to launch a DLL, failing\n");
3575  Result = FALSE;
3576  goto Quickie;
3577  }
3578 
3579  /* Don't let callers pass in this flag -- we'll only get it from IFEO */
3581 
3582  /* Clear the IFEO-missing flag, before we know for sure... */
3583  ParameterFlags &= ~2;
3584 
3585  /* If the process is being debugged, only read IFEO if the PEB says so */
3586  if (!(dwCreationFlags & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS)) ||
3587  (NtCurrentPeb()->ReadImageFileExecOptions))
3588  {
3589  /* Let's do this! Attempt to open IFEO */
3590  IFEOStatus = LdrOpenImageFileOptionsKey(&PathName, 0, &KeyHandle);
3591  if (!NT_SUCCESS(IFEOStatus))
3592  {
3593  /* We failed, set the flag so we store this in the parameters */
3594  if (IFEOStatus == STATUS_OBJECT_NAME_NOT_FOUND) ParameterFlags |= 2;
3595  }
3596  else
3597  {
3598  /* Was this our first time going through this path? */
3599  if (!DebuggerCmdLine)
3600  {
3601  /* Allocate a buffer for the debugger path */
3602  DebuggerCmdLine = RtlAllocateHeap(RtlGetProcessHeap(),
3603  0,
3604  MAX_PATH * sizeof(WCHAR));
3605  if (!DebuggerCmdLine)
3606  {
3607  /* Close IFEO on failure */
3608  IFEOStatus = NtClose(KeyHandle);
3609  ASSERT(NT_SUCCESS(IFEOStatus));
3610 
3611  /* Fail the call */
3613  Result = FALSE;
3614  goto Quickie;
3615  }
3616  }
3617 
3618  /* Now query for the debugger */
3620  L"Debugger",
3621  REG_SZ,
3622  DebuggerCmdLine,
3623  MAX_PATH * sizeof(WCHAR),
3624  &ResultSize);
3625  if (!(NT_SUCCESS(IFEOStatus)) ||
3626  (ResultSize < sizeof(WCHAR)) ||
3627  (DebuggerCmdLine[0] == UNICODE_NULL))
3628  {
3629  /* If it's not there, or too small, or invalid, ignore it */
3630  RtlFreeHeap(RtlGetProcessHeap(), 0, DebuggerCmdLine);
3631  DebuggerCmdLine = NULL;
3632  }
3633 
3634  /* Also query if we should map with large pages */
3636  L"UseLargePages",
3637  REG_DWORD,
3638  &UseLargePages,
3639  sizeof(UseLargePages),
3640  NULL);
3641  if ((NT_SUCCESS(IFEOStatus)) && (UseLargePages))
3642  {
3643  /* Do it! This is the only way this flag can be set */
3645  }
3646 
3647  /* We're done with IFEO, can close it now */
3648  IFEOStatus = NtClose(KeyHandle);
3649  ASSERT(NT_SUCCESS(IFEOStatus));
3650  }
3651  }
3652 
3653  /* Make sure the image was compiled for this processor */
3654  if ((ImageInformation.Machine < SharedUserData->ImageNumberLow) ||
3655  (ImageInformation.Machine > SharedUserData->ImageNumberHigh))
3656  {
3657  /* It was not -- raise a hard error */
3658  ErrorResponse = ResponseOk;
3659  ErrorParameters[0] = (ULONG_PTR)&PathName;
3661  1,
3662  1,
3663  ErrorParameters,
3664  OptionOk,
3665  &ErrorResponse);
3666  if (Peb->ImageSubsystemMajorVersion <= 3)
3667  {
3668  /* If it's really old, return this error */
3670  }
3671  else
3672  {
3673  /* Otherwise, return a more modern error */
3675  }
3676 
3677  /* Go to the failure path */
3678  DPRINT1("Invalid image architecture: %lx\n", ImageInformation.Machine);
3679  Result = FALSE;
3680  goto Quickie;
3681  }
3682 
3683  /* Check if this isn't a Windows image */
3684  if ((ImageInformation.SubSystemType != IMAGE_SUBSYSTEM_WINDOWS_GUI) &&
3685  (ImageInformation.SubSystemType != IMAGE_SUBSYSTEM_WINDOWS_CUI))
3686  {
3687  /* Get rid of section-related information since we'll retry */
3688  NtClose(SectionHandle);
3689  SectionHandle = NULL;
3690  QuerySection = FALSE;
3691 
3692  /* The only other non-Windows image type we support here is POSIX */
3693  if (ImageInformation.SubSystemType != IMAGE_SUBSYSTEM_POSIX_CUI)
3694  {
3695  /* Bail out if it's something else */
3697  Result = FALSE;
3698  goto Quickie;
3699  }
3700 
3701  /* Now build the command-line to have posix launch this image */
3702  Result = BuildSubSysCommandLine(L"POSIX /P ",
3703  lpApplicationName,
3704  lpCommandLine,
3705  &DebuggerString);
3706  if (!Result)
3707  {
3708  /* Bail out if that failed */
3709  DPRINT1("Subsystem command line failed\n");
3710  goto Quickie;
3711  }
3712 
3713  /* And re-try launching the process, with the new command-line now */
3714  lpCommandLine = DebuggerString.Buffer;
3715  lpApplicationName = NULL;
3716 
3717  /* We've already done all these checks, don't do them again */
3718  SkipSaferAndAppCompat = TRUE;
3719  DPRINT1("Retrying with: %S\n", lpCommandLine);
3720  goto AppNameRetry;
3721  }
3722 
3723  /* Was this image built for a version of Windows whose images we can run? */
3725  ImageInformation.SubSystemMinorVersion);
3726  if (!Result)
3727  {
3728  /* It was not, bail out */
3729  DPRINT1("Invalid subsystem version: %hu.%hu\n",
3730  ImageInformation.SubSystemMajorVersion,
3731  ImageInformation.SubSystemMinorVersion);
3733  goto Quickie;
3734  }
3735 
3736  /* Check if there is a debugger associated with the application */
3737  if (DebuggerCmdLine)
3738  {
3739  /* Get the length of the command line */
3740  n = wcslen(lpCommandLine);
3741  if (!n)
3742  {
3743  /* There's no command line, use the application name instead */
3744  lpCommandLine = (LPWSTR)lpApplicationName;
3745  n = wcslen(lpCommandLine);
3746  }
3747 
3748  /* Protect against overflow */
3750  {
3752  Result = FALSE;
3753  goto Quickie;
3754  }
3755 
3756  /* Now add the length of the debugger command-line */
3757  n += wcslen(DebuggerCmdLine);
3758 
3759  /* Again make sure we don't overflow */
3761  {
3763  Result = FALSE;
3764  goto Quickie;
3765  }
3766 
3767  /* Account for the quotes and space between the two */
3768  n += sizeof("\" \"") - sizeof(ANSI_NULL);
3769 
3770  /* Convert to bytes, and make sure we don't overflow */
3771  n *= sizeof(WCHAR);
3773  {
3775  Result = FALSE;
3776  goto Quickie;
3777  }
3778 
3779  /* Allocate space for the string */
3780  DebuggerString.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, n);
3781  if (!DebuggerString.Buffer)
3782  {
3784  Result = FALSE;
3785  goto Quickie;
3786  }
3787 
3788  /* Set the length */
3789  RtlInitEmptyUnicodeString(&DebuggerString,
3790  DebuggerString.Buffer,
3791  (USHORT)n);
3792 
3793  /* Now perform the command line creation */
3794  ImageDbgStatus = RtlAppendUnicodeToString(&DebuggerString,
3795  DebuggerCmdLine);
3796  ASSERT(NT_SUCCESS(ImageDbgStatus));
3797  ImageDbgStatus = RtlAppendUnicodeToString(&DebuggerString, L" ");
3798  ASSERT(NT_SUCCESS(ImageDbgStatus));
3799  ImageDbgStatus = RtlAppendUnicodeToString(&DebuggerString, lpCommandLine);
3800  ASSERT(NT_SUCCESS(ImageDbgStatus));
3801 
3802  /* Make sure it all looks nice */
3803  DbgPrint("BASE: Calling debugger with '%wZ'\n", &DebuggerString);
3804 
3805  /* Update the command line and application name */
3806  lpCommandLine = DebuggerString.Buffer;
3807  lpApplicationName = NULL;
3808 
3809  /* Close all temporary state */
3810  NtClose(SectionHandle);
3811  SectionHandle = NULL;
3812  QuerySection = FALSE;
3813 
3814  /* Free all temporary memory */
3815  RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
3816  NameBuffer = NULL;
3817  RtlFreeHeap(RtlGetProcessHeap(), 0, FreeBuffer);
3818  FreeBuffer = NULL;
3819  RtlFreeHeap(RtlGetProcessHeap(), 0, DebuggerCmdLine);
3820  DebuggerCmdLine = NULL;
3821  DPRINT1("Retrying with: %S\n", lpCommandLine);
3822  goto AppNameRetry;
3823  }
3824 
3825  /* Initialize the process object attributes */
3826  ObjectAttributes = BaseFormatObjectAttributes(&LocalObjectAttributes,
3827  lpProcessAttributes,
3828  NULL);
3829  if ((hUserToken) && (lpProcessAttributes))
3830  {
3831  /* Augment them with information from the user */
3832 
3833  LocalProcessAttributes = *lpProcessAttributes;
3834  LocalProcessAttributes.lpSecurityDescriptor = NULL;
3835  ObjectAttributes = BaseFormatObjectAttributes(&LocalObjectAttributes,
3836  &LocalProcessAttributes,
3837  NULL);
3838  }
3839 
3840  /* Check if we're going to be debugged */
3841  if (dwCreationFlags & DEBUG_PROCESS)
3842  {
3843  /* Set process flag */
3845  }
3846 
3847  /* Check if we're going to be debugged */
3848  if (dwCreationFlags & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS))
3849  {
3850  /* Connect to DbgUi */
3852  if (!NT_SUCCESS(Status))
3853  {
3854  DPRINT1("Failed to connect to DbgUI!\n");
3856  Result = FALSE;
3857  goto Quickie;
3858  }
3859 
3860  /* Get the debug object */
3861  DebugHandle = DbgUiGetThreadDebugObject();
3862 
3863  /* Check if only this process will be debugged */
3864  if (dwCreationFlags & DEBUG_ONLY_THIS_PROCESS)
3865  {
3866  /* Set process flag */
3868  }
3869  }
3870 
3871  /* Set inherit flag */
3872  if (bInheritHandles) Flags |= PROCESS_CREATE_FLAGS_INHERIT_HANDLES;
3873 
3874  /* Check if the process should be created with large pages */
3875  HavePrivilege = FALSE;
3876  PrivilegeState = NULL;
3878  {
3879  /* Acquire the required privilege so that the kernel won't fail the call */
3880  PrivilegeValue = SE_LOCK_MEMORY_PRIVILEGE;
3881  Status = RtlAcquirePrivilege(&PrivilegeValue, 1, 0, &PrivilegeState);
3882  if (NT_SUCCESS(Status))
3883  {
3884  /* Remember to release it later */
3885  HavePrivilege = TRUE;
3886  }
3887  }
3888 
3889  /* Save the current TIB value since kernel overwrites it to store PEB */
3890  TibValue = Teb->NtTib.ArbitraryUserPointer;
3891 
3892  /* Tell the kernel to create the process */
3896  NtCurrentProcess(),
3897  Flags,
3898  SectionHandle,
3899  DebugHandle,
3900  NULL,
3901  InJob);
3902 
3903  /* Load the PEB address from the hacky location where the kernel stores it */
3904  RemotePeb = Teb->NtTib.ArbitraryUserPointer;
3905 
3906  /* And restore the old TIB value */
3907  Teb->NtTib.ArbitraryUserPointer = TibValue;
3908 
3909  /* Release the large page privilege if we had acquired it */
3910  if (HavePrivilege) RtlReleasePrivilege(PrivilegeState);
3911 
3912  /* And now check if the kernel failed to create the process */
3913  if (!NT_SUCCESS(Status))
3914  {
3915  /* Go to failure path */
3916  DPRINT1("Failed to create process: %lx\n", Status);
3918  Result = FALSE;
3919  goto Quickie;
3920  }
3921 
3922  /* Check if there is a priority class to set */
3923  if (PriorityClass.PriorityClass)
3924  {
3925  /* Reset current privilege state */
3926  RealTimePrivilegeState = NULL;
3927 
3928  /* Is realtime priority being requested? */
3929  if (PriorityClass.PriorityClass == PROCESS_PRIORITY_CLASS_REALTIME)
3930  {
3931  /* Check if the caller has real-time access, and enable it if so */
3932  RealTimePrivilegeState = BasepIsRealtimeAllowed(TRUE);
3933  }
3934 
3935  /* Set the new priority class and release the privilege */
3938  &PriorityClass,
3939  sizeof(PROCESS_PRIORITY_CLASS));
3940  if (RealTimePrivilegeState) RtlReleasePrivilege(RealTimePrivilegeState);
3941 
3942  /* Check if we failed to set the priority class */
3943  if (!NT_SUCCESS(Status))
3944  {
3945  /* Bail out on failure */
3946  DPRINT1("Failed to set priority class: %lx\n", Status);
3948  Result = FALSE;
3949  goto Quickie;
3950  }
3951  }
3952 
3953  /* Check if the caller wants the default error mode */
3954  if (dwCreationFlags & CREATE_DEFAULT_ERROR_MODE)
3955  {
3956  /* Set Error Mode to only fail on critical errors */
3957  HardErrorMode = SEM_FAILCRITICALERRORS;
3960  &HardErrorMode,
3961  sizeof(ULONG));
3962  }
3963 
3964  /* Check if this was a VDM binary */
3965  if (VdmBinaryType)
3966  {
3967  /* Update VDM by telling it the process has now been created */
3968  VdmWaitObject = ProcessHandle;
3970  &VdmWaitObject,
3971  VdmTask,
3972  VdmBinaryType);
3973 
3974  if (!Result)
3975  {
3976  /* Bail out on failure */
3977  DPRINT1("Failed to update VDM with wait object\n");
3978  VdmWaitObject = NULL;
3979  goto Quickie;
3980  }
3981 
3982  /* At this point, a failure means VDM has to undo all the state */
3983  VdmUndoLevel |= VDM_UNDO_FULL;
3984  }
3985 
3986  /* Check if VDM needed reserved low-memory */
3987  if (VdmReserve)
3988  {
3989  /* Reserve the requested allocation */
3990  RegionSize = VdmReserve;
3992  &BaseAddress,
3993  0,
3994  &RegionSize,
3995  MEM_RESERVE,
3997  if (!NT_SUCCESS(Status))
3998  {
3999  /* Bail out on failure */
4000  DPRINT1("Failed to reserve memory for VDM: %lx\n", Status);
4002  Result = FALSE;
4003  goto Quickie;
4004  }
4005 
4006  VdmReserve = (ULONG)RegionSize;
4007  }
4008 
4009  /* Check if we've already queried information on the section */
4010  if (!QuerySection)
4011  {
4012  /* We haven't, so get some information about the executable */
4013  Status = NtQuerySection(SectionHandle,
4015  &ImageInformation,
4016  sizeof(ImageInformation),
4017  NULL);
4018  if (!NT_SUCCESS(Status))
4019  {
4020  /* Bail out on failure */
4021  DPRINT1("Failed to query section: %lx\n", Status);
4023  Result = FALSE;
4024  goto Quickie;
4025  }
4026 
4027  /* If we encounter a restart, don't re-query this information again */
4028  QuerySection = TRUE;
4029  }
4030 
4031  /* Do we need to apply SxS to this image? */
4033  {
4034  /* Too bad, we don't support this yet */
4035  DPRINT1("Image should receive SxS Fusion Isolation\n");
4036  }
4037 
4038  /* There's some SxS flag that we need to set if fusion flags have 1 set */
4039  if (FusionFlags & 1) CreateProcessMsg->Sxs.Flags |= 0x10;
4040 
4041  /* Check if we have a current directory */
4042  if (lpCurrentDirectory)
4043  {
4044  /* Allocate a buffer so we can keep a Unicode copy */
4045  DPRINT("Current directory: %S\n", lpCurrentDirectory);
4046  CurrentDirectory = RtlAllocateHeap(RtlGetProcessHeap(),
4047  0,
4048  (MAX_PATH * sizeof(WCHAR)) +
4049  sizeof(UNICODE_NULL));
4050  if (!CurrentDirectory)
4051  {
4052  /* Bail out if this failed */
4054  Result = FALSE;
4055  goto Quickie;
4056  }
4057 
4058  /* Get the length in Unicode */
4059  Length = GetFullPathNameW(lpCurrentDirectory,
4060  MAX_PATH,
4062  &FilePart);
4063  if (Length > MAX_PATH)
4064  {
4065  /* The directory is too long, so bail out */
4067  Result = FALSE;
4068  goto Quickie;
4069  }
4070 
4071  /* Make sure the directory is actually valid */
4072  FileAttribs = GetFileAttributesW(CurrentDirectory);
4073  if ((FileAttribs == INVALID_FILE_ATTRIBUTES) ||
4074  !(FileAttribs & FILE_ATTRIBUTE_DIRECTORY))
4075  {
4076  /* It isn't, so bail out */
4077  DPRINT1("Current directory is invalid\n");
4079  Result = FALSE;
4080  goto Quickie;
4081  }
4082  }
4083 
4084  /* Insert quotes if needed */
4085  if ((QuotesNeeded) || (CmdLineIsAppName))
4086  {
4087  /* Allocate our buffer, plus enough space for quotes and a NULL */
4088  QuotedCmdLine = RtlAllocateHeap(RtlGetProcessHeap(),
4089  0,
4090  (wcslen(lpCommandLine) * sizeof(WCHAR)) +
4091  (2 * sizeof(L'\"') + sizeof(UNICODE_NULL)));
4092  if (QuotedCmdLine)
4093  {
4094  /* Copy the first quote */
4095  wcscpy(QuotedCmdLine, L"\"");
4096 
4097  /* Save the current null-character */
4098  if (QuotesNeeded)
4099  {
4100  SaveChar = *NullBuffer;
4101  *NullBuffer = UNICODE_NULL;
4102  }
4103 
4104  /* Copy the command line and the final quote */
4105  wcscat(QuotedCmdLine, lpCommandLine);
4106  wcscat(QuotedCmdLine, L"\"");
4107 
4108  /* Copy the null-char back */
4109  if (QuotesNeeded)
4110  {
4111  *NullBuffer = SaveChar;
4112  wcscat(QuotedCmdLine, NullBuffer);
4113  }
4114  }
4115  else
4116  {
4117  /* We can't put quotes around the thing, so try it anyway */
4118  if (QuotesNeeded) QuotesNeeded = FALSE;
4119  if (CmdLineIsAppName) CmdLineIsAppName = FALSE;
4120  }
4121  }
4122 
4123  /* Use isolation if needed */
4124  if (CreateProcessMsg->Sxs.Flags & 1) ParameterFlags |= 1;
4125 
4126  /* Set the new command-line if needed */
4127  if ((QuotesNeeded) || (CmdLineIsAppName)) lpCommandLine = QuotedCmdLine;
4128 
4129  /* Call the helper function in charge of RTL_USER_PROCESS_PARAMETERS */
4130  Result = BasePushProcessParameters(ParameterFlags,
4131  ProcessHandle,
4132  RemotePeb,
4133  lpApplicationName,
4135  lpCommandLine,
4136  lpEnvironment,
4137  &StartupInfo,
4138  dwCreationFlags | NoWindow,
4139  bInheritHandles,
4140  IsWowApp ? IMAGE_SUBSYSTEM_WINDOWS_GUI: 0,
4141  AppCompatData,
4142  AppCompatDataSize);
4143  if (!Result)
4144  {
4145  /* The remote process would have an undefined state, so fail the call */
4146  DPRINT1("BasePushProcessParameters failed\n");
4147  goto Quickie;
4148  }
4149 
4150  /* Free the VDM command line string as it's no longer needed */
4151  RtlFreeUnicodeString(&VdmString);
4152  VdmString.Buffer = NULL;
4153 
4154  /* Non-VDM console applications usually inherit handles unless specified */
4155  if (!(VdmBinaryType) &&
4156  !(bInheritHandles) &&
4157  !(StartupInfo.dwFlags & STARTF_USESTDHANDLES) &&
4158  !(dwCreationFlags & (CREATE_NO_WINDOW |
4160  DETACHED_PROCESS)) &&
4161  (ImageInformation.SubSystemType == IMAGE_SUBSYSTEM_WINDOWS_CUI))
4162  {
4163  /* Get the remote parameters */
4165  &RemotePeb->ProcessParameters,
4166  &ProcessParameters,
4168  NULL);
4169  if (NT_SUCCESS(Status))
4170  {
4171  /* Duplicate standard input unless it's a console handle */
4173  {
4176  &ProcessParameters->StandardInput);
4177  }
4178 
4179  /* Duplicate standard output unless it's a console handle */
4181  {
4184  &ProcessParameters->StandardOutput);
4185  }
4186 
4187  /* Duplicate standard error unless it's a console handle */
4189  {
4192  &ProcessParameters->StandardError);
4193  }
4194  }
4195  }
4196 
4197  /* Create the Thread's Stack */
4198  StackSize = max(256 * 1024, ImageInformation.MaximumStackSize);
4200  ImageInformation.CommittedStackSize,
4201  StackSize,
4202  &InitialTeb);
4203  if (!NT_SUCCESS(Status))
4204  {
4205  DPRINT1("Creating the thread stack failed: %lx\n", Status);
4207  Result = FALSE;
4208  goto Quickie;
4209  }
4210 
4211  /* Create the Thread's Context */
4213  Peb,
4214  ImageInformation.TransferAddress,
4215  InitialTeb.StackBase,
4216  0);
4217 
4218  /* Convert the thread attributes */
4219  ObjectAttributes = BaseFormatObjectAttributes(&LocalObjectAttributes,
4220  lpThreadAttributes,
4221  NULL);
4222  if ((hUserToken) && (lpThreadAttributes))
4223  {
4224  /* If the caller specified a user token, zero the security descriptor */
4225  LocalThreadAttributes = *lpThreadAttributes;
4226  LocalThreadAttributes.lpSecurityDescriptor = NULL;
4227  ObjectAttributes = BaseFormatObjectAttributes(&LocalObjectAttributes,
4228  &LocalThreadAttributes,
4229  NULL);
4230  }
4231 
4232  /* Create the Kernel Thread Object */
4233  Status = NtCreateThread(&ThreadHandle,
4236  ProcessHandle,
4237  &ClientId,
4238  &Context,
4239  &InitialTeb,
4240  TRUE);
4241  if (!NT_SUCCESS(Status))
4242  {
4243  /* A process is not allowed to exist without a main thread, so fail */
4244  DPRINT1("Creating the main thread failed: %lx\n", Status);
4246  Result = FALSE;
4247  goto Quickie;
4248  }
4249 
4250  /* Begin filling out the CSRSS message, first with our IDs and handles */
4251  CreateProcessMsg->ProcessHandle = ProcessHandle;
4252  CreateProcessMsg->ThreadHandle = ThreadHandle;
4253  CreateProcessMsg->ClientId = ClientId;
4254 
4255  /* Write the remote PEB address and clear it locally, we no longer use it */
4256  CreateProcessMsg->PebAddressNative = RemotePeb;
4257 #ifdef _WIN64
4258  DPRINT1("TODO: WOW64 is not supported yet\n");
4259  CreateProcessMsg->PebAddressWow64 = 0;
4260 #else
4261  CreateProcessMsg->PebAddressWow64 = (ULONG)RemotePeb;
4262 #endif
4263  RemotePeb = NULL;
4264 
4265  /* Now check what kind of architecture this image was made for */
4266  switch (ImageInformation.Machine)
4267  {
4268  /* IA32, IA64 and AMD64 are supported in Server 2003 */
4271  break;
4274  break;
4277  break;
4278 
4279  /* Anything else results in image unknown -- but no failure */
4280  default:
4281  DbgPrint("kernel32: No mapping for ImageInformation.Machine == %04x\n",
4282  ImageInformation.Machine);
4284  break;
4285  }
4286 
4287  /* Write the input creation flags except any debugger-related flags */
4288  CreateProcessMsg->CreationFlags = dwCreationFlags &
4290 
4291  /* CSRSS needs to know if this is a GUI app or not */
4292  if ((ImageInformation.SubSystemType == IMAGE_SUBSYSTEM_WINDOWS_GUI) ||
4293  (IsWowApp))
4294  {
4295  /*
4296  * For GUI apps we turn on the 2nd bit. This allow CSRSS server dlls
4297  * (basesrv in particular) to know whether or not this is a GUI or a
4298  * TUI application.
4299  */
4300  AddToHandle(CreateProcessMsg->ProcessHandle, 2);
4301 
4302  /* Also check if the parent is also a GUI process */
4303  NtHeaders = RtlImageNtHeader(GetModuleHandle(NULL));
4304  if ((NtHeaders) &&
4306  {
4307  /* Let it know that it should display the hourglass mouse cursor */
4308  AddToHandle(CreateProcessMsg->ProcessHandle, 1);
4309  }
4310  }
4311 
4312  /* For all apps, if this flag is on, the hourglass mouse cursor is shown */
4313  if (StartupInfo.dwFlags & STARTF_FORCEONFEEDBACK)
4314  {
4315  AddToHandle(CreateProcessMsg->ProcessHandle, 1);
4316  }
4317 
4318  /* Likewise, the opposite holds as well */
4319  if (StartupInfo.dwFlags & STARTF_FORCEOFFFEEDBACK)
4320  {
4321  RemoveFromHandle(CreateProcessMsg->ProcessHandle, 1);
4322  }
4323 
4324  /* Also store which kind of VDM app (if any) this is */
4325  CreateProcessMsg->VdmBinaryType = VdmBinaryType;
4326 
4327  /* And if it really is a VDM app... */
4328  if (VdmBinaryType)
4329  {
4330  /* Store the task ID and VDM console handle */
4331  CreateProcessMsg->hVDM = VdmTask ? 0 : Peb->ProcessParameters->ConsoleHandle;
4332  CreateProcessMsg->VdmTask = VdmTask;
4333  }
4334  else if (VdmReserve)
4335  {
4336  /* Extended VDM, set a flag */
4337  CreateProcessMsg->VdmBinaryType |= BINARY_TYPE_WOW_EX;
4338  }
4339 
4340  /* Check if there's side-by-side assembly data associated with the process */
4341  if (CreateProcessMsg->Sxs.Flags)
4342  {
4343  /* This should not happen in ReactOS yet */
4344  DPRINT1("This is an SxS Message -- should not happen yet\n");
4347  Result = FALSE;
4348  goto Quickie;
4349  }
4350 
4351  /* We are finally ready to call CSRSS to tell it about our new process! */
4353  CaptureBuffer,
4356  sizeof(*CreateProcessMsg));
4357 
4358  /* CSRSS has returned, free the capture buffer now if we had one */
4359  if (CaptureBuffer)
4360  {
4361  CsrFreeCaptureBuffer(CaptureBuffer);
4362  CaptureBuffer = NULL;
4363  }
4364 
4365  /* Check if CSRSS failed to accept ownership of the new Windows process */
4366  if (!NT_SUCCESS(CsrMsg[0].Status))
4367  {
4368  /* Terminate the process and enter failure path with the CSRSS status */
4369  DPRINT1("Failed to tell csrss about new process\n");
4370  BaseSetLastNTError(CsrMsg[0].Status);
4372  Result = FALSE;
4373  goto Quickie;
4374  }
4375 
4376  /* Check if we have a token due to Authz/Safer, not passed by the user */
4377  if ((TokenHandle) && !(hUserToken))
4378  {
4379  /* Replace the process and/or thread token with the one from Safer */
4381  ProcessHandle,
4382  ThreadHandle);
4383  if (!NT_SUCCESS(Status))
4384  {
4385  /* If this failed, kill the process and enter the failure path */
4386  DPRINT1("Failed to update process token: %lx\n", Status);
4389  Result = FALSE;
4390  goto Quickie;
4391  }
4392  }
4393 
4394  /* Check if a job was associated with this process */
4395  if (JobHandle)
4396  {
4397  /* Bind the process and job together now */
4399  if (!NT_SUCCESS(Status))
4400  {
4401  /* Kill the process and enter the failure path if binding failed */
4402  DPRINT1("Failed to assign process to job: %lx\n", Status);
4405  Result = FALSE;
4406  goto Quickie;
4407  }
4408  }
4409 
4410  /* Finally, resume the thread to actually get the process started */
4411  if (!(dwCreationFlags & CREATE_SUSPENDED))
4412  {
4413  NtResumeThread(ThreadHandle, &ResumeCount);
4414  }
4415 
4416 VdmShortCircuit:
4417  /* We made it this far, meaning we have a fully created process and thread */
4418  Result = TRUE;
4419 
4420  /* Anyone doing a VDM undo should now undo everything, since we are done */
4421  if (VdmUndoLevel) VdmUndoLevel |= VDM_UNDO_COMPLETED;
4422 
4423  /* Having a VDM wait object implies this must be a VDM process */
4424  if (VdmWaitObject)
4425  {
4426  /* Check if it's a 16-bit separate WOW process */
4427  if (VdmBinaryType == BINARY_TYPE_SEPARATE_WOW)
4428  {
4429  /* OR-in the special flag to indicate this, and return to caller */
4430  AddToHandle(VdmWaitObject, 2);
4431  lpProcessInformation->hProcess = VdmWaitObject;
4432 
4433  /* Check if this was a re-used VDM */
4434  if (VdmUndoLevel & VDM_UNDO_REUSE)
4435  {
4436  /* No Client ID should be returned in this case */
4437  ClientId.UniqueProcess = 0;
4438  ClientId.UniqueThread = 0;
4439  }
4440  }
4441  else
4442  {
4443  /* OR-in the special flag to indicate this is not a separate VDM */
4444  AddToHandle(VdmWaitObject, 1);
4445 
4446  /* Return handle to the caller */
4447  lpProcessInformation->hProcess = VdmWaitObject;
4448  }
4449 
4450  /* Close the original process handle, since it's not needed for VDM */
4452  }
4453  else
4454  {
4455  /* This is a regular process, so return the real process handle */
4456  lpProcessInformation->hProcess = ProcessHandle;
4457  }
4458 
4459  /* Return the rest of the process information based on what we have so far */
4460  lpProcessInformation->hThread = ThreadHandle;
4461  lpProcessInformation->dwProcessId = HandleToUlong(ClientId.UniqueProcess);
4462  lpProcessInformation->dwThreadId = HandleToUlong(ClientId.UniqueThread);
4463 
4464  /* NULL these out here so we know to treat this as a success scenario */
4465  ProcessHandle = NULL;
4466  ThreadHandle = NULL;
4467 
4468 Quickie:
4469  /* Free the debugger command line if one was allocated */
4470  if (DebuggerCmdLine) RtlFreeHeap(RtlGetProcessHeap(), 0, DebuggerCmdLine);
4471 
4472  /* Check if an SxS full path as queried */
4473  if (PathBuffer)
4474  {
4475  /* Reinitialize the executable path */
4476  RtlInitEmptyUnicodeString(&SxsWin32ExePath, NULL, 0);
4477  SxsWin32ExePath.Length = 0;
4478 
4479  /* Free the path buffer */
4480  RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
4481  }
4482 
4483 #if _SXS_SUPPORT_ENABLED_
4484  /* Check if this was a non-VDM process */
4485  if (!VdmBinaryType)
4486  {
4487  /* Then it must've had SxS data, so close the handles used for it */
4488  BasepSxsCloseHandles(&Handles);
4489  BasepSxsCloseHandles(&FileHandles);
4490 
4491  /* Check if we built SxS byte buffers for this create process request */
4492  if (SxsConglomeratedBuffer)
4493  {
4494  /* Loop all of them */
4495  for (i = 0; i < 5; i++)
4496  {
4497  /* Check if this one was allocated */
4498  ThisBuffer = SxsStaticBuffers[i];
4499  if (ThisBuffer)
4500  {
4501  /* Get the underlying RTL_BUFFER structure */
4502  ByteBuffer = &ThisBuffer->ByteBuffer;
4503  if ((ThisBuffer != (PVOID)-8) && (ByteBuffer->Buffer))
4504  {
4505  /* Check if it was dynamic */
4506  if (ByteBuffer->Buffer != ByteBuffer->StaticBuffer)
4507  {
4508  /* Free it from the heap */
4509  FreeString.Buffer = (PWCHAR)ByteBuffer->Buffer;
4510  RtlFreeUnicodeString(&FreeString);
4511  }
4512 
4513  /* Reset the buffer to its static data */
4514  ByteBuffer->Buffer = ByteBuffer->StaticBuffer;
4515  ByteBuffer->Size = ByteBuffer->StaticSize;
4516  }
4517 
4518  /* Reset the string to the static buffer */
4519  RtlInitEmptyUnicodeString(&ThisBuffer->String,
4520  (PWCHAR)ByteBuffer->StaticBuffer,
4521  ByteBuffer->StaticSize);
4522  if (ThisBuffer->String.Buffer)
4523  {
4524  /* Also NULL-terminate it */
4525  *ThisBuffer->String.Buffer = UNICODE_NULL;
4526  }
4527  }
4528  }
4529  }
4530  }
4531 #endif
4532  /* Check if an environment was passed in */
4533  if ((lpEnvironment) && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT))
4534  {
4535  /* Destroy it */
4536  RtlDestroyEnvironment(lpEnvironment);
4537 
4538  /* If this was the VDM environment too, clear that as well */
4539  if (VdmUnicodeEnv.Buffer == lpEnvironment) VdmUnicodeEnv.Buffer = NULL;
4540  lpEnvironment = NULL;
4541  }
4542 
4543  /* Unconditionally free all the name parsing buffers we always allocate */
4544  RtlFreeHeap(RtlGetProcessHeap(), 0, QuotedCmdLine);
4545  RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
4546  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDirectory);
4547  RtlFreeHeap(RtlGetProcessHeap(), 0, FreeBuffer);
4548 
4549  /* Close open file/section handles */
4551  if (SectionHandle) NtClose(SectionHandle);
4552 
4553  /* If we have a thread handle, this was a failure path */
4554  if (ThreadHandle)
4555  {
4556  /* So kill the process and close the thread handle */
4558  NtClose(ThreadHandle);
4559  }
4560 
4561  /* If we have a process handle, this was a failure path, so close it */
4563 
4564  /* Thread/process handles, if any, are now processed. Now close this one. */
4565  if (JobHandle) NtClose(JobHandle);
4566 
4567  /* Check if we had created a token */
4568  if (TokenHandle)
4569  {
4570  /* And if the user asked for one */
4571  if (hUserToken)
4572  {
4573  /* Then return it */
4574  *hNewToken = TokenHandle;
4575  }
4576  else
4577  {
4578  /* User didn't want it, so we used it temporarily -- close it */
4580  }
4581  }
4582 
4583  /* Free any temporary app compatibility data, it's no longer needed */
4584  BasepFreeAppCompatData(AppCompatData, AppCompatSxsData);
4585 
4586  /* Free a few strings. The API takes care of these possibly being NULL */
4587  RtlFreeUnicodeString(&VdmString);
4588  RtlFreeUnicodeString(&DebuggerString);
4589 
4590  /* Check if we had built any sort of VDM environment */
4591  if ((VdmAnsiEnv.Buffer) || (VdmUnicodeEnv.Buffer))
4592  {
4593  /* Free it */
4594  BaseDestroyVDMEnvironment(&VdmAnsiEnv, &VdmUnicodeEnv);
4595  }
4596 
4597  /* Check if this was any kind of VDM application that we ended up creating */
4598  if ((VdmUndoLevel) && (!(VdmUndoLevel & VDM_UNDO_COMPLETED)))
4599  {
4600  /* Send an undo */
4602  (PHANDLE)&VdmTask,
4603  VdmUndoLevel,
4604  VdmBinaryType);
4605 
4606  /* And close whatever VDM handle we were using for notifications */
4607  if (VdmWaitObject) NtClose(VdmWaitObject);
4608  }
4609 
4610  /* Check if we ended up here with an allocated search path, and free it */
4611  if (SearchPath) RtlFreeHeap(RtlGetProcessHeap(), 0, SearchPath);
4612 
4613  /* Finally, return the API's result */
4614  return Result;
4615 }
HANDLE NTAPI DbgUiGetThreadDebugObject(VOID)
Definition: dbgui.c:333
BASE_SXS_CREATEPROCESS_MSG Sxs
Definition: basemsg.h:96
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
VOID WINAPI BasepFreeAppCompatData(IN PVOID AppCompatData, IN PVOID AppCompatSxsData)
Definition: appcache.c:342
#define ERROR_CHILD_NOT_COMPLETE
Definition: winerror.h:201
PVOID WINAPI BasepIsRealtimeAllowed(IN BOOLEAN Keep)
Definition: utils.c:653
ULONG ImageSubsystemMajorVersion
Definition: ntddk_ex.h:305
VOID NTAPI CsrFreeCaptureBuffer(IN PCSR_CAPTURE_BUFFER CaptureBuffer)
Definition: capture.c:189
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
enum _RTL_PATH_TYPE RTL_PATH_TYPE
#define STATUS_INVALID_IMAGE_WIN_64
Definition: ntstatus.h:887
#define RemoveFromHandle(x, y)
Definition: proc.c:2256
NTSTATUS NTAPI DbgUiConnectToDbg(VOID)
Definition: dbgui.c:25
NTSTATUS NTAPI LdrQueryImageFileKeyOption(IN HANDLE KeyHandle, IN PCWSTR ValueName, IN ULONG Type, OUT PVOID Buffer, IN ULONG BufferSize, OUT PULONG ReturnedLength OPTIONAL)
Definition: ldrinit.c:184
VOID WINAPI BaseInitializeContext(IN PCONTEXT Context, IN PVOID Parameter, IN PVOID StartAddress, IN PVOID StackAddress, IN ULONG ContextType)
Definition: utils.c:503
#define max(a, b)
Definition: svc.c:63
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
PVOID PVOID PWCHAR PVOID USHORT PULONG PVOID PULONG PVOID PULONG PULONG FusionFlags
Definition: env.c:45
#define REALTIME_PRIORITY_CLASS
Definition: winbase.h:184
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:398
#define IMAGE_SUBSYSTEM_POSIX_CUI
Definition: ntimage.h:440
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4418
PPEB Peb
Definition: dllmain.c:27
#define CREATE_FORCEDOS
Definition: winbase.h:189
#define PROCESS_PRIORITY_CLASS_INVALID
Definition: pstypes.h:106
#define PROCESS_ALL_ACCESS
Definition: nt_native.h:1324
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3371
#define SEM_FAILCRITICALERRORS
Definition: rtltypes.h:69
NTSYSAPI NTSTATUS NTAPI NtCreateThread(OUT PHANDLE phThread, IN ACCESS_MASK AccessMask, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE hProcess, OUT PCLIENT_ID pClientId, IN PCONTEXT pContext, OUT PSTACKINFO pStackInfo, IN BOOLEAN bSuspended)
NTSTATUS NTAPI NtRaiseHardError(IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, IN PULONG_PTR Parameters, IN ULONG ValidResponseOptions, OUT PULONG Response)
Definition: harderr.c:553
#define BINARY_TYPE_WOW
Definition: vdm.h:40
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4693
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define DbgPrint
Definition: loader.c:25
BOOL WINAPI BaseUpdateVDMEntry(IN ULONG UpdateIndex, IN OUT PHANDLE WaitHandle, IN ULONG IndexInfo, IN ULONG BinaryType)
Definition: vdm.c:534
SIZE_T Size
Definition: rtltypes.h:1809
PBASE_STATIC_SERVER_DATA BaseStaticServerData
Definition: dllmain.c:19
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define CREATE_SEPARATE_WOW_VDM
Definition: winbase.h:187
#define CREATE_UNICODE_ENVIRONMENT
Definition: winbase.h:186
#define PROCESSOR_ARCHITECTURE_UNKNOWN
Definition: ketypes.h:115
WCHAR CurrentDirectory[1024]
Definition: chkdsk.c:74
#define SE_LOCK_MEMORY_PRIVILEGE
Definition: security.c:658
#define AddToHandle(x, y)
Definition: proc.c:2255
NTSYSAPI VOID NTAPI RtlDestroyEnvironment(_In_ PWSTR Environment)
union _BASE_API_MESSAGE::@3379 Data
BOOL NTAPI BaseCreateVDMEnvironment(IN PWCHAR lpEnvironment, OUT PANSI_STRING AnsiEnv, OUT PUNICODE_STRING UnicodeEnv)
Definition: vdm.c:736
NTSTATUS WINAPI BasepCheckWinSaferRestrictions(IN HANDLE UserToken, IN LPWSTR ApplicationName, IN HANDLE FileHandle, OUT PBOOLEAN InJob, OUT PHANDLE NewToken, OUT PHANDLE JobHandle)
Definition: utils.c:909
static DWORD ResumeCount
Definition: database.c:32
NTSTATUS NTAPI CsrClientCallServer(IN OUT PCSR_API_MESSAGE ApiMessage, IN OUT PCSR_CAPTURE_BUFFER CaptureBuffer OPTIONAL, IN CSR_API_NUMBER ApiNumber, IN ULONG DataLength)
Definition: connect.c:360
HANDLE ContainingDirectory
Definition: rtltypes.h:1375
#define VER_SUITE_BLADE
BOOL WINAPI BaseGetVdmConfigInfo(IN LPCWSTR CommandLineReserved, IN ULONG DosSeqId, IN ULONG BinaryType, IN PUNICODE_STRING CmdLineString, OUT PULONG VdmSize)
Definition: vdm.c:644
BASE_CREATE_PROCESS CreateProcessRequest
Definition: basemsg.h:283
BOOL NTAPI BaseDestroyVDMEnvironment(IN PANSI_STRING AnsiEnv, IN PUNICODE_STRING UnicodeEnv)
Definition: vdm.c:1026
VOID NTAPI RtlReleaseRelativeName(_In_ PRTL_RELATIVE_NAME_U RelativeName)
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN DefaultSeparateVDM
Definition: base.h:126
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:603
#define HandleToUlong(h)
Definition: basetsd.h:79
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
GLdouble n
Definition: glext.h:7729
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1105
#define ERROR_BAD_DEVICE
Definition: winerror.h:703
#define CREATE_DEFAULT_ERROR_MODE
Definition: winbase.h:194
NTSTATUS NTAPI RtlGetFullPathName_UstrEx(_In_ PUNICODE_STRING FileName, _In_opt_ PUNICODE_STRING StaticString, _In_opt_ PUNICODE_STRING DynamicString, _Out_opt_ PUNICODE_STRING *StringUsed, _Out_opt_ PSIZE_T FilePartSize, _Out_opt_ PBOOLEAN NameInvalid, _Out_ RTL_PATH_TYPE *PathType, _Out_opt_ PSIZE_T LengthNeeded)
#define VDM_UNDO_COMPLETED
Definition: vdm.h:30
uint16_t * PWCHAR
Definition: typedefs.h:54
#define STARTF_FORCEONFEEDBACK
Definition: winbase.h:478
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define NORMAL_PRIORITY_CLASS
Definition: winbase.h:181
#define PROCESS_CREATE_FLAGS_LARGE_PAGES
Definition: pstypes.h:95
HANDLE UniqueProcess
Definition: compat.h:474
UNICODE_STRING DesktopInfo
Definition: rtltypes.h:1526
#define UNICODE_STRING_MAX_BYTES
#define ERROR_DIRECTORY
Definition: winerror.h:295
#define ERROR_ACCESS_DISABLED_WEBBLADE
Definition: winerror.h:774
#define MEM_COMMIT
Definition: nt_native.h:1313
#define VER_SUITE_DATACENTER
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
#define STATUS_VDM_DISALLOWED
Definition: ntstatus.h:943
#define VER_SUITE_PERSONAL
PVOID ArbitraryUserPointer
Definition: compat.h:379
NTSTATUS NTAPI LdrOpenImageFileOptionsKey(IN PUNICODE_STRING SubKey, IN BOOLEAN Wow64, OUT PHANDLE NewKeyHandle)
Definition: ldrinit.c:112
#define IMAGE_FILE_DLL
Definition: pedump.c:169
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
#define FILE_SHARE_READ
Definition: compat.h:125
#define STARTF_FORCEOFFFEEDBACK
Definition: winbase.h:479
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToRelativeNtPathName_U(_In_ PCWSTR DosName, _Out_ PUNICODE_STRING NtName, _Out_ PCWSTR *PartName, _Out_ PRTL_RELATIVE_NAME_U RelativeName)
#define SearchPath
Definition: winbase.h:3714
#define ABOVE_NORMAL_PRIORITY_CLASS
Definition: winbase.h:191
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define PROCESSOR_ARCHITECTURE_IA64
Definition: ketypes.h:111
#define CREATE_NO_WINDOW
Definition: winbase.h:195
HANDLE ThreadHandle
Definition: basemsg.h:90
static IN ULONG IN PWSTR OUT PCWSTR OUT PBOOLEAN OUT PATH_TYPE_AND_UNKNOWN * PathType
#define VDM_READY
Definition: vdm.h:48
HANDLE FileHandle
Definition: stats.c:38
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define CREATE_SUSPENDED
Definition: winbase.h:178
static HANDLE hUserToken
Definition: umpnpmgr.c:67
#define UNICODE_NULL
#define ANSI_NULL
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
BOOLEAN WINAPI BasepIsImageVersionOk(IN ULONG ImageMajorVersion, IN ULONG ImageMinorVersion)
Definition: proc.c:123
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:802
#define STARTF_SHELLPRIVATE
Definition: kernel32.h:60
#define FILE_READ_DATA
Definition: nt_native.h:628
HANDLE WaitObjectForParent
Definition: basemsg.h:123
#define MEM_RESERVE
Definition: nt_native.h:1314
LPWSTR lpDesktop
Definition: winbase.h:819
BASE_CHECK_VDM CheckVDMRequest
Definition: basemsg.h:287
#define IMAGE_SUBSYSTEM_WINDOWS_CUI
Definition: ntimage.h:438
#define HIGH_PRIORITY_CLASS
Definition: winbase.h:183
unsigned char BOOLEAN
#define ERROR_BAD_EXE_FORMAT
Definition: winerror.h:251
smooth NULL
Definition: ftsmooth.c:416
#define ERROR_NOT_READY
Definition: winerror.h:124
NTSYSAPI VOID NTAPI RtlReleasePrivilege(_In_ PVOID ReturnedState)
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define PAGE_EXECUTE
Definition: nt_native.h:1306
PVOID StackBase
Definition: pstypes.h:678
void DPRINT(...)
Definition: polytest.cpp:61
_In_ ACCESS_MASK _In_ ULONG _Out_ PHANDLE TokenHandle
Definition: psfuncs.h:715
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
#define PROCESS_PRIORITY_CLASS_NORMAL
Definition: pstypes.h:108
void * PVOID
Definition: retypes.h:9
NTSTATUS WINAPI BasepReplaceProcessThreadTokens(IN HANDLE TokenHandle, IN HANDLE ProcessHandle, IN HANDLE ThreadHandle)
Definition: proc.c:354
NTSTATUS NTAPI NtQuerySection(_In_ HANDLE SectionHandle, _In_ SECTION_INFORMATION_CLASS SectionInformationClass, _Out_ PVOID SectionInformation, _In_ SIZE_T SectionInformationLength, _Out_opt_ PSIZE_T ResultLength)
Definition: section.c:4253
#define OPEN_EXISTING
Definition: compat.h:426
#define VDM_UNDO_FULL
Definition: vdm.h:28
#define STATUS_NAME_TOO_LONG
Definition: ntstatus.h:484
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define PCHAR
Definition: match.c:90
#define CSR_CREATE_API_NUMBER(ServerId, ApiId)
Definition: csrmsg.h:37
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:585
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
#define PROCESS_PRIORITY_CLASS_ABOVE_NORMAL
Definition: pstypes.h:112
#define CREATE_SHARED_WOW_VDM
Definition: winbase.h:188
#define STATUS_INVALID_IMAGE_PROTECT
Definition: ntstatus.h:526
#define STARTF_USESTDHANDLES
Definition: winbase.h:480
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
USHORT MaximumLength
Definition: env_spec_w32.h:377
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:525
#define CMD_STRING
Definition: proc.c:51
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
#define IDLE_PRIORITY_CLASS
Definition: winbase.h:182
#define PROCESS_CREATE_FLAGS_INHERIT_HANDLES
Definition: pstypes.h:93
#define UNICODE_STRING_MAX_CHARS
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
#define CREATE_NEW_CONSOLE
Definition: winbase.h:180
#define PROCESS_PRIORITY_CLASS_REALTIME
Definition: pstypes.h:110
#define BASESRV_SERVERDLL_INDEX
Definition: basemsg.h:15
BOOLEAN IsWowTaskReady
Definition: base.h:127
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG WINAPI BaseIsDosApplication(IN PUNICODE_STRING PathName, IN NTSTATUS Status)
Definition: vdm.c:66
#define IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
Definition: ntimage.h:458
#define MAX_PATH
Definition: compat.h:26
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define SetLastError(x)
Definition: compat.h:409
#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE
Definition: ntstatus.h:149
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define BINARY_TYPE_SEPARATE_WOW
Definition: vdm.h:39
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
#define PROCESS_PRIORITY_CLASS_HIGH
Definition: pstypes.h:109
#define DEBUG_PROCESS
Definition: winbase.h:176
HANDLE ProcessHandle
Definition: basemsg.h:89
#define IsConsoleHandle(h)
Definition: console.h:14
NTSTATUS NTAPI NtReadVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, OUT PVOID Buffer, IN SIZE_T NumberOfBytesToRead, OUT PSIZE_T NumberOfBytesRead OPTIONAL)
Definition: virtual.c:2691
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define PROCESSOR_ARCHITECTURE_AMD64
Definition: ketypes.h:114
HANDLE UniqueThread
Definition: compat.h:475
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define ERROR_EXE_MACHINE_TYPE_MISMATCH
Definition: winerror.h:271
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define SharedUserData
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
static const WCHAR L[]
Definition: oid.c:1250
NTSTATUS WINAPI BaseCreateStack(HANDLE hProcess, SIZE_T StackCommit, SIZE_T StackReserve, PINITIAL_TEB InitialTeb)
Definition: utils.c:353
UNICODE_STRING String
Definition: rtltypes.h:1817
PRTL_USER_PROCESS_PARAMETERS ProcessParameters
Definition: btrfs_drv.h:1838
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
#define FILE_EXECUTE
Definition: nt_native.h:642
PUNICODE_STRING Nt
Definition: kernel32.h:401
#define FILE_NON_DIRECTORY_FILE
Definition: constants.h:492
#define GENERIC_READ
Definition: compat.h:124
#define VDM_UNDO_REUSE
Definition: vdm.h:29
_In_ USHORT _In_ CCHAR StackSize
Definition: iofuncs.h:1056
#define SYNCHRONIZE
Definition: nt_native.h:61
#define PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT
Definition: pstypes.h:92
POBJECT_ATTRIBUTES WINAPI BaseFormatObjectAttributes(OUT POBJECT_ATTRIBUTES ObjectAttributes, IN PSECURITY_ATTRIBUTES SecurityAttributes OPTIONAL, IN PUNICODE_STRING ObjectName)
Definition: utils.c:304
NTSTATUS NTAPI NtAssignProcessToJobObject(HANDLE JobHandle, HANDLE ProcessHandle)
Definition: job.c:157
DWORD WINAPI SearchPathW(IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
Definition: path.c:1297
Status
Definition: gdiplustypes.h:24
PUCHAR StaticBuffer
Definition: rtltypes.h:1808
#define PROCESSOR_ARCHITECTURE_INTEL
Definition: ketypes.h:105
#define STATUS_FILE_IS_OFFLINE
Definition: ntstatus.h:726
ULONG_PTR SIZE_T
Definition: typedefs.h:78
Definition: compat.h:484
#define ERROR_FILE_OFFLINE
Definition: winerror.h:1285
#define VER_SUITE_EMBEDDEDNT
NTSTATUS WINAPI BaseCheckVDM(IN ULONG BinaryType, IN PCWCH ApplicationName, IN PCWCH CommandLine, IN PCWCH CurrentDirectory, IN PANSI_STRING AnsiEnvironment, IN PBASE_API_MESSAGE ApiMessage, IN OUT PULONG iTask, IN DWORD CreationFlags, IN LPSTARTUPINFOW StartupInfo, IN HANDLE hUserToken OPTIONAL)
Definition: vdm.c:91
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4367
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1089
LPVOID lpSecurityDescriptor
Definition: compat.h:181
#define GetModuleHandle
Definition: winbase.h:3641
#define ERROR_CANCELLED
Definition: winerror.h:726
#define NtCurrentPeb()
Definition: FLS.c:19
unsigned short USHORT
Definition: pedump.c:61
__kernel_entry _Inout_ _Inout_ PSIZE_T RegionSize
Definition: mmfuncs.h:172
VOID WINAPI StuffStdHandle(IN HANDLE ProcessHandle, IN HANDLE StandardHandle, IN PHANDLE Address)
Definition: proc.c:57
SIZE_T StaticSize
Definition: rtltypes.h:1810
NTSTATUS WINAPI BasepCheckWebBladeHashes(IN HANDLE FileHandle)
Definition: proc.c:149
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
#define VDM_NOT_LOADED
Definition: vdm.h:46
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
#define VDM_NOT_READY
Definition: vdm.h:47
#define DETACHED_PROCESS
Definition: winbase.h:179
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define VDM_UNDO_PARTIAL
Definition: vdm.h:27
#define PROCESS_CREATE_FLAGS_BREAKAWAY
Definition: pstypes.h:91
LPWSTR WINAPI BaseComputeProcessExePath(IN LPWSTR FullPath)
Definition: path.c:405
USHORT ProcessorArchitecture
Definition: basemsg.h:99
#define MAXUSHORT
Definition: typedefs.h:81
USHORT VDMState
Definition: basemsg.h:147
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:457
#define CreateFileW
Definition: compat.h:400
PUNICODE_STRING Win32
Definition: kernel32.h:400
NTSYSAPI NTSTATUS NTAPI RtlAcquirePrivilege(_In_ PULONG Privilege, _In_ ULONG NumPriv, _In_ ULONG Flags, _Out_ PVOID *ReturnedState)
#define BINARY_TYPE_WOW_EX
Definition: vdm.h:41
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
#define MEM_RELEASE
Definition: nt_native.h:1316
PUCHAR Buffer
Definition: rtltypes.h:1807
#define STATUS_INVALID_IMAGE_NE_FORMAT
Definition: ntstatus.h:505
PVOID PebAddressNative
Definition: basemsg.h:97
#define BELOW_NORMAL_PRIORITY_CLASS
Definition: winbase.h:190
struct tagContext Context
Definition: acpixf.h:1012
ULONG PebAddressWow64
Definition: basemsg.h:98
CLIENT_ID ClientId
Definition: basemsg.h:91
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
NTSTATUS NTAPI NtTerminateProcess(HANDLE ProcessHandle, LONG ExitStatus)
#define ULONG_PTR
Definition: config.h:101
#define BINARY_TYPE_DOS
Definition: vdm.h:38
#define SEC_IMAGE
Definition: mmtypes.h:96
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
UNICODE_STRING RelativeName
Definition: rtltypes.h:1374
#define PROCESS_PRIORITY_CLASS_BELOW_NORMAL
Definition: pstypes.h:111
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
DWORD dwFlags
Definition: winbase.h:828
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1308
#define ERROR_ACCESS_DISABLED_WEBBLADE_TAMPER
Definition: winerror.h:775
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define ERROR_ACCESS_DISABLED_BY_POLICY
Definition: winerror.h:763
NTSTATUS NTAPI NtIsProcessInJob(IN HANDLE ProcessHandle, IN HANDLE JobHandle OPTIONAL)
Definition: job.c:361
#define PROCESS_PRIORITY_CLASS_IDLE
Definition: pstypes.h:107
#define CREATE_PRESERVE_CODE_AUTHZ_LEVEL
Definition: winbase.h:193
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
#define DEBUG_ONLY_THIS_PROCESS
Definition: winbase.h:177
return STATUS_SUCCESS
Definition: btrfs.c:2725
BOOLEAN WINAPI BuildSubSysCommandLine(IN LPCWSTR SubsystemName, IN LPCWSTR ApplicationName, IN LPCWSTR CommandLine, OUT PUNICODE_STRING SubsysCommandLine)
Definition: proc.c:89
#define REG_DWORD
Definition: sdbapi.c:596
NTSTATUS NTAPI NtCreateProcessEx(OUT PHANDLE ProcessHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN HANDLE ParentProcess, IN ULONG Flags, IN HANDLE SectionHandle OPTIONAL, IN HANDLE DebugPort OPTIONAL, IN HANDLE ExceptionPort OPTIONAL, IN BOOLEAN InJob)
Definition: process.c:1344
VOID WINAPI BasepSxsCloseHandles(IN PBASE_MSG_SXS_HANDLES Handles)
Definition: proc.c:417
#define STATUS_INVALID_IMAGE_WIN_16
Definition: ntstatus.h:527
#define IMAGE_FILE_MACHINE_IA64
Definition: ntimage.h:22
NT_TIB NtTib
Definition: ntddk_ex.h:332
NTSYSAPI ULONG NTAPI RtlIsDosDeviceName_U(_In_ PCWSTR Name)
NTSTATUS WINAPI BasepIsProcessAllowed(IN LPWSTR ApplicationName)
Definition: proc.c:202
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
BOOLEAN WINAPI BasePushProcessParameters(IN ULONG ParameterFlags, IN HANDLE ProcessHandle, IN PPEB RemotePeb, IN LPCWSTR ApplicationPathName, IN LPWSTR lpCurrentDirectory, IN LPWSTR lpCommandLine, IN LPVOID lpEnvironment, IN LPSTARTUPINFOW StartupInfo, IN DWORD CreationFlags, IN BOOL InheritHandles, IN ULONG ImageSubsystem, IN PVOID AppCompatData, IN ULONG AppCompatDataSize)
Definition: proc.c:514
#define BINARY_TYPE_EXE
Definition: vdm.h:35
#define PAGE_READWRITE
Definition: nt_native.h:1304
NTSYSAPI RTL_PATH_TYPE NTAPI RtlDetermineDosPathNameType_U(_In_ PCWSTR Path)
#define IMAGE_SUBSYSTEM_WINDOWS_GUI
Definition: ntimage.h:437
NTSTATUS WINAPI BasepCheckBadapp(IN HANDLE FileHandle, IN PWCHAR ApplicationName, IN PWCHAR Environment, IN USHORT ExeType, IN PVOID *SdbQueryAppCompatData, IN PULONG SdbQueryAppCompatDataSize, IN PVOID *SxsData, IN PULONG SxsDataSize, OUT PULONG FusionFlags)
Definition: appcache.c:272
#define REG_SZ
Definition: layer.c:22
NTSTATUS NTAPI NtFreeVirtualMemory(IN HANDLE ProcessHandle, IN PVOID *UBaseAddress, IN PSIZE_T URegionSize, IN ULONG FreeType)
Definition: virtual.c:5090

Referenced by CreateProcessInternalA(), and CreateProcessW().

◆ CreateProcessW()

BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW ( LPCWSTR  lpApplicationName,
LPWSTR  lpCommandLine,
LPSECURITY_ATTRIBUTES  lpProcessAttributes,
LPSECURITY_ATTRIBUTES  lpThreadAttributes,
BOOL  bInheritHandles,
DWORD  dwCreationFlags,
LPVOID  lpEnvironment,
LPCWSTR  lpCurrentDirectory,
LPSTARTUPINFOW  lpStartupInfo,
LPPROCESS_INFORMATION  lpProcessInformation 
)

Definition at line 4623 of file proc.c.

4633 {
4634  /* Call the internal (but exported) version */
4636  lpApplicationName,
4637  lpCommandLine,
4638  lpProcessAttributes,
4639  lpThreadAttributes,
4640  bInheritHandles,
4641  dwCreationFlags,
4642  lpEnvironment,
4643  lpCurrentDirectory,
4644  lpStartupInfo,
4645  lpProcessInformation,
4646  NULL);
4647 }
BOOL WINAPI CreateProcessInternalW(IN HANDLE hUserToken, IN LPCWSTR lpApplicationName, IN LPWSTR lpCommandLine, IN LPSECURITY_ATTRIBUTES lpProcessAttributes, IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN BOOL bInheritHandles, IN DWORD dwCreationFlags, IN LPVOID lpEnvironment, IN LPCWSTR lpCurrentDirectory, IN LPSTARTUPINFOW lpStartupInfo, IN LPPROCESS_INFORMATION lpProcessInformation, OUT PHANDLE hNewToken)
Definition: proc.c:2264
smooth NULL
Definition: ftsmooth.c:416

Referenced by CorDebug_CreateProcess(), CProcess::CProcess(), create_server(), CreateClientProcess(), CNewMenu::CreateNewItem(), CreateProcessAsUserW(), CreateProcessWithTokenW(), do_register_dll(),