mirror of
https://github.com/reactos/reactos.git
synced 2024-12-28 10:04:49 +00:00
630 lines
14 KiB
C
630 lines
14 KiB
C
/* $Id: spawn.c,v 1.9 2002/12/26 18:14:36 robd Exp $
|
|
*/
|
|
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS POSIX+ Subsystem
|
|
* FILE: subsys/psx/lib/psxdll/misc/spawn.c
|
|
* PURPOSE: Create the first POSIX+ process
|
|
* PROGRAMMER: KJK::Hyperion <noog@libero.it>
|
|
* UPDATE HISTORY:
|
|
* 25/02/2002: Created
|
|
*/
|
|
|
|
/*
|
|
* NOTE by KJK::Hyperion:
|
|
* The __PdxSpawnPosixProcess() call solves the chicken-egg dilemma of
|
|
* creating the first POSIX+ process in a group without the ability to
|
|
* fork+exec (for example from inside a Win32 process). Processes created by
|
|
* __PdxSpawnPosixProcess() will *not* inherit anything from the parent, not
|
|
* even handles: all creation parameters have to be specified explicitely
|
|
*/
|
|
|
|
#include <ddk/ntddk.h>
|
|
#include <ntdll/base.h>
|
|
#include <napi/i386/segment.h>
|
|
#include <ntdll/rtl.h>
|
|
#include <ntdll/ldr.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <inttypes.h>
|
|
#include <unistd.h>
|
|
#include <psx/debug.h>
|
|
#include <psx/pdata.h>
|
|
#include <psx/spawn.h>
|
|
#include <psx/stdlib.h>
|
|
|
|
#include <windows.h>
|
|
|
|
typedef struct _PORT_MESSAGE {
|
|
USHORT DataSize;
|
|
USHORT MessageSize;
|
|
USHORT MessageType;
|
|
USHORT VirtualRangesOffset;
|
|
CLIENT_ID ClientId;
|
|
ULONG MessageId;
|
|
ULONG SectionSize;
|
|
// UCHAR Data[];
|
|
} PORT_MESSAGE, *PPORT_MESSAGE;
|
|
|
|
NTSTATUS STDCALL CsrClientCallServer(
|
|
IN PVOID Message,
|
|
IN PVOID Unknown,
|
|
IN ULONG Opcode,
|
|
IN ULONG Size
|
|
);
|
|
|
|
NTSTATUS STDCALL __PdxSpawnPosixProcess
|
|
(
|
|
OUT PHANDLE ProcessHandle,
|
|
OUT PHANDLE ThreadHandle,
|
|
IN POBJECT_ATTRIBUTES FileObjectAttributes,
|
|
IN POBJECT_ATTRIBUTES ProcessObjectAttributes,
|
|
IN HANDLE InheritFromProcessHandle,
|
|
IN __PPDX_PDATA ProcessData
|
|
)
|
|
{
|
|
struct CSRSS_MESSAGE {
|
|
ULONG Unknown1;
|
|
ULONG Opcode;
|
|
ULONG Status;
|
|
ULONG Unknown2;
|
|
};
|
|
|
|
struct __tagcsrmsg{
|
|
PORT_MESSAGE PortMessage;
|
|
struct CSRSS_MESSAGE CsrssMessage;
|
|
PROCESS_INFORMATION ProcessInformation;
|
|
CLIENT_ID Debugger;
|
|
ULONG CreationFlags;
|
|
ULONG VdmInfo[2];
|
|
} csrmsg;
|
|
|
|
__PPDX_SERIALIZED_PDATA pspdProcessData;
|
|
IO_STATUS_BLOCK isbStatus;
|
|
PROCESS_BASIC_INFORMATION pbiProcessInfo;
|
|
INITIAL_TEB itInitialTeb;
|
|
PRTL_USER_PROCESS_PARAMETERS pppProcessParameters;
|
|
SECTION_IMAGE_INFORMATION siiInfo;
|
|
CONTEXT ctxThreadContext;
|
|
CLIENT_ID ciClientId;
|
|
NTSTATUS nErrCode;
|
|
HANDLE hExeFile;
|
|
HANDLE hExeImage;
|
|
HANDLE hProcess;
|
|
PVOID pPdataBuffer = 0;
|
|
PVOID pParamsBuffer = 0;
|
|
ULONG nDestBufferSize;
|
|
ULONG nCurFilDesOffset;
|
|
ULONG nVirtualSize;
|
|
ULONG nCommitSize;
|
|
PVOID pCommitBottom;
|
|
ULONG nOldProtect;
|
|
int i;
|
|
|
|
/* STEP 1: map executable image in memory */
|
|
/* 1.1: open the file for execution */
|
|
nErrCode = NtOpenFile
|
|
(
|
|
&hExeFile,
|
|
SYNCHRONIZE | FILE_EXECUTE,
|
|
FileObjectAttributes,
|
|
&isbStatus,
|
|
FILE_SHARE_READ | FILE_SHARE_DELETE,
|
|
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtOpenFile() failed with status 0x%08X\n", nErrCode);
|
|
return (nErrCode);
|
|
}
|
|
|
|
/* 1.2: create an image section for the file */
|
|
nErrCode = NtCreateSection
|
|
(
|
|
&hExeImage,
|
|
SECTION_ALL_ACCESS,
|
|
NULL,
|
|
0,
|
|
PAGE_EXECUTE,
|
|
SEC_IMAGE,
|
|
hExeFile
|
|
);
|
|
|
|
/* close file handle (not needed anymore) */
|
|
NtClose(hExeFile);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtCreateSection() failed with status 0x%08X\n", nErrCode);
|
|
return (nErrCode);
|
|
}
|
|
|
|
/* 1.3: get section image information */
|
|
nErrCode = NtQuerySection
|
|
(
|
|
hExeImage,
|
|
SectionImageInformation,
|
|
&siiInfo,
|
|
sizeof(siiInfo),
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtCreateSection() failed with status 0x%08X\n", nErrCode);
|
|
NtClose(hExeImage);
|
|
return (nErrCode);
|
|
}
|
|
|
|
/* STEP 2: create process */
|
|
nErrCode = NtCreateProcess
|
|
(
|
|
&hProcess,
|
|
PROCESS_ALL_ACCESS,
|
|
ProcessObjectAttributes,
|
|
InheritFromProcessHandle,
|
|
FALSE,
|
|
hExeImage,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
/* close image handle (not needed anymore) */
|
|
NtClose(hExeImage);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtCreateProcess() failed with status 0x%08X\n", nErrCode);
|
|
return (nErrCode);
|
|
}
|
|
|
|
/* STEP 3: write process environment and process parameters */
|
|
/* 3.1: convert process data into process parameters */
|
|
__PdxProcessDataToProcessParameters
|
|
(
|
|
&pppProcessParameters,
|
|
ProcessData,
|
|
FileObjectAttributes->ObjectName
|
|
);
|
|
|
|
/* 3.2: serialize the process data for transfer */
|
|
/* FIXME: the serialized data can be allocated and written directly in the
|
|
destination process */
|
|
__PdxSerializeProcessData(ProcessData, &pspdProcessData);
|
|
|
|
/* 3.2.1: adjust some fields */
|
|
pspdProcessData->ProcessData.Spawned = TRUE;
|
|
|
|
/* 3.3: allocate memory in the destination process */
|
|
/* 3.3.1: process data */
|
|
nDestBufferSize = pspdProcessData->AllocSize;
|
|
|
|
nErrCode = NtAllocateVirtualMemory
|
|
(
|
|
hProcess,
|
|
&pPdataBuffer,
|
|
0,
|
|
&nDestBufferSize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtAllocateVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.3.2: process parameters */
|
|
nDestBufferSize = pppProcessParameters->Size;
|
|
|
|
nErrCode = NtAllocateVirtualMemory
|
|
(
|
|
hProcess,
|
|
&pParamsBuffer,
|
|
0,
|
|
&nDestBufferSize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtAllocateVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.4: get pointer to the PEB */
|
|
nErrCode = NtQueryInformationProcess
|
|
(
|
|
hProcess,
|
|
ProcessBasicInformation,
|
|
&pbiProcessInfo,
|
|
sizeof(pbiProcessInfo),
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtQueryInformationProcess() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.5: write pointers in the PEB */
|
|
/* 3.5.1: process data */
|
|
nErrCode = NtWriteVirtualMemory
|
|
(
|
|
hProcess,
|
|
(PVOID)((ULONG)pbiProcessInfo.PebBaseAddress + offsetof(PEB, SubSystemData)),
|
|
&pPdataBuffer,
|
|
sizeof(PVOID),
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtWriteVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.5.2: process parameters */
|
|
nErrCode = NtWriteVirtualMemory
|
|
(
|
|
hProcess,
|
|
(PVOID)((ULONG)pbiProcessInfo.PebBaseAddress + offsetof(PEB, ProcessParameters)),
|
|
&pParamsBuffer,
|
|
sizeof(PVOID),
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtWriteVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.6: write data */
|
|
/* 3.6.1: process data */
|
|
nErrCode = NtWriteVirtualMemory
|
|
(
|
|
hProcess,
|
|
pPdataBuffer,
|
|
pspdProcessData,
|
|
pspdProcessData->AllocSize,
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtWriteVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
/* 3.6.2 process parameters */
|
|
nErrCode = NtWriteVirtualMemory
|
|
(
|
|
hProcess,
|
|
pParamsBuffer,
|
|
pppProcessParameters,
|
|
pppProcessParameters->Size,
|
|
NULL
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtWriteVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto undoPData;
|
|
}
|
|
|
|
undoPData:
|
|
/* deallocate the temporary data block in the current process */
|
|
NtFreeVirtualMemory
|
|
(
|
|
NtCurrentProcess(),
|
|
(PVOID *)&pspdProcessData,
|
|
0,
|
|
MEM_RELEASE
|
|
);
|
|
|
|
/* destroy process parameters */
|
|
RtlDestroyProcessParameters(pppProcessParameters);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
goto failProcess;
|
|
|
|
/* STEP 4: duplicate handles */
|
|
/* 4.1: handles in the structure itself */
|
|
/* 4.1.1: root directory */
|
|
nErrCode = NtDuplicateObject
|
|
(
|
|
NtCurrentProcess(),
|
|
ProcessData->RootHandle,
|
|
hProcess,
|
|
(PHANDLE)((ULONG)pPdataBuffer + offsetof(__PDX_PDATA, RootHandle)),
|
|
0,
|
|
0,
|
|
DUPLICATE_SAME_ACCESS | 4 /* | DUPLICATE_SAME_ATTRIBUTES */ /* FIXME */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtDuplicateObject() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* 4.2: file descriptors table */
|
|
for
|
|
(
|
|
/* pspdProcessData->ProcessData.FdTable.Descriptors contains the offset to
|
|
the descriptors array inside pspdProcessData->Buffer[], that is to the
|
|
first element of the array */
|
|
i = 0,
|
|
nCurFilDesOffset = (ULONG)pspdProcessData->ProcessData.FdTable.Descriptors;
|
|
/* iterate through all allocated descriptors */
|
|
i < ProcessData->FdTable.AllocatedDescriptors;
|
|
/* at every step, go on to next input descriptor, and increase the offset to
|
|
the next output descriptor */
|
|
i ++, nCurFilDesOffset += sizeof(__fildes_t)
|
|
)
|
|
/* FIXME? check the table's bitmap instead? */
|
|
if(ProcessData->FdTable.Descriptors[i].FileHandle != NULL)
|
|
{
|
|
/* duplicate the source handle, ProcessData->FdTable.Descriptors[i], from
|
|
the current process into the process identified by hProcess, at an
|
|
address calculated by adding to the serialized data block base address:
|
|
- the offset to the current descriptor
|
|
- the offset to the handle field of the descriptor */
|
|
nErrCode = NtDuplicateObject
|
|
(
|
|
NtCurrentProcess(),
|
|
ProcessData->FdTable.Descriptors[i].FileHandle,
|
|
hProcess,
|
|
(PHANDLE)(
|
|
(ULONG)pPdataBuffer + nCurFilDesOffset + offsetof(__fildes_t, FileHandle)
|
|
),
|
|
0,
|
|
0,
|
|
DUPLICATE_SAME_ACCESS | 4 /* | DUPLICATE_SAME_ATTRIBUTES */ /* FIXME */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtDuplicateObject() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* duplicate standard handles */
|
|
/* standard input */
|
|
if(i == STDIN_FILENO)
|
|
{
|
|
nErrCode = NtDuplicateObject
|
|
(
|
|
NtCurrentProcess(),
|
|
ProcessData->FdTable.Descriptors[i].FileHandle,
|
|
hProcess,
|
|
(PHANDLE)((ULONG)pParamsBuffer + offsetof(RTL_USER_PROCESS_PARAMETERS, hStdInput)),
|
|
0,
|
|
0,
|
|
DUPLICATE_SAME_ACCESS | 4 /* | DUPLICATE_SAME_ATTRIBUTES */ /* FIXME */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtDuplicateObject() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
}
|
|
/* standard output */
|
|
else if(i == STDOUT_FILENO)
|
|
{
|
|
nErrCode = NtDuplicateObject
|
|
(
|
|
NtCurrentProcess(),
|
|
ProcessData->FdTable.Descriptors[i].FileHandle,
|
|
hProcess,
|
|
(PHANDLE)((ULONG)pParamsBuffer + offsetof(RTL_USER_PROCESS_PARAMETERS, hStdOutput)),
|
|
0,
|
|
0,
|
|
DUPLICATE_SAME_ACCESS | 4 /* | DUPLICATE_SAME_ATTRIBUTES */ /* FIXME */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtDuplicateObject() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
}
|
|
/* standard error */
|
|
else if(i == STDERR_FILENO)
|
|
{
|
|
nErrCode = NtDuplicateObject
|
|
(
|
|
NtCurrentProcess(),
|
|
ProcessData->FdTable.Descriptors[i].FileHandle,
|
|
hProcess,
|
|
(PHANDLE)((ULONG)pParamsBuffer + offsetof(RTL_USER_PROCESS_PARAMETERS, hStdError)),
|
|
0,
|
|
0,
|
|
DUPLICATE_SAME_ACCESS | 4 /* | DUPLICATE_SAME_ATTRIBUTES */ /* FIXME */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtDuplicateObject() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* STEP 5: create first thread */
|
|
/* 5.1: set up the stack */
|
|
itInitialTeb.StackAllocate = NULL;
|
|
nVirtualSize = 0x100000;
|
|
nCommitSize = 0x100000 - PAGE_SIZE;
|
|
|
|
/* 5.1.1: reserve the stack */
|
|
nErrCode = NtAllocateVirtualMemory
|
|
(
|
|
hProcess,
|
|
&itInitialTeb.StackAllocate,
|
|
0,
|
|
&nVirtualSize,
|
|
MEM_RESERVE,
|
|
PAGE_READWRITE
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtAllocateVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
itInitialTeb.StackBase =
|
|
(PVOID)((ULONG)itInitialTeb.StackAllocate + nVirtualSize);
|
|
|
|
itInitialTeb.StackLimit =
|
|
(PVOID)((ULONG)itInitialTeb.StackBase - nCommitSize);
|
|
|
|
/* 5.1.2: commit the stack */
|
|
nVirtualSize = nCommitSize + PAGE_SIZE;
|
|
pCommitBottom =
|
|
(PVOID)((ULONG)itInitialTeb.StackBase - nVirtualSize);
|
|
|
|
nErrCode = NtAllocateVirtualMemory
|
|
(
|
|
hProcess,
|
|
&pCommitBottom,
|
|
0,
|
|
&nVirtualSize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtAllocateVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* 5.1.3: set up the guard page */
|
|
nVirtualSize = PAGE_SIZE;
|
|
|
|
nErrCode = NtProtectVirtualMemory
|
|
(
|
|
hProcess,
|
|
&pCommitBottom,
|
|
&nVirtualSize,
|
|
PAGE_GUARD | PAGE_READWRITE,
|
|
&nOldProtect
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtProtectVirtualMemory() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* 5.2: initialize the thread context */
|
|
memset(&ctxThreadContext, 0, sizeof(ctxThreadContext));
|
|
|
|
ctxThreadContext.Eip = (ULONG)siiInfo.EntryPoint;
|
|
ctxThreadContext.SegGs = USER_DS;
|
|
ctxThreadContext.SegFs = USER_DS;
|
|
ctxThreadContext.SegEs = USER_DS;
|
|
ctxThreadContext.SegDs = USER_DS;
|
|
ctxThreadContext.SegCs = USER_CS;
|
|
ctxThreadContext.SegSs = USER_DS;
|
|
ctxThreadContext.Esp = (ULONG)itInitialTeb.StackBase - 4;
|
|
ctxThreadContext.EFlags = (1 << 1) + (1 << 9);
|
|
|
|
/* 5.3: create the thread object */
|
|
nErrCode = NtCreateThread
|
|
(
|
|
ThreadHandle,
|
|
THREAD_ALL_ACCESS,
|
|
NULL,
|
|
hProcess,
|
|
&ciClientId,
|
|
&ctxThreadContext,
|
|
&itInitialTeb,
|
|
TRUE /* FIXME: the thread is only created in suspended state for easier
|
|
debugging. This behavior is subject to future changes */
|
|
);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtCreateThread() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* 6: register the process with the Win32 subsystem (temporary code for
|
|
debugging purposes) */
|
|
|
|
memset(&csrmsg, 0, sizeof(csrmsg));
|
|
|
|
//csrmsg.PortMessage = {0};
|
|
//csrmsg.CsrssMessage = {0};
|
|
csrmsg.ProcessInformation.hProcess = hProcess;
|
|
csrmsg.ProcessInformation.hThread = *ThreadHandle;
|
|
csrmsg.ProcessInformation.dwProcessId = (DWORD)ciClientId.UniqueProcess;
|
|
csrmsg.ProcessInformation.dwThreadId = (DWORD)ciClientId.UniqueThread;
|
|
//csrmsg.Debugger = {0};
|
|
//csrmsg.CreationFlags = 0;
|
|
//csrmsg.VdmInfo = {0};
|
|
|
|
nErrCode = CsrClientCallServer(&csrmsg, 0, 0x10000, 0x24);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("CsrClientCallServer() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
nErrCode = NtResumeThread(*ThreadHandle, NULL);
|
|
|
|
/* failure */
|
|
if(!NT_SUCCESS(nErrCode))
|
|
{
|
|
ERR("NtResumeThread() failed with status 0x%08X\n", nErrCode);
|
|
goto failProcess;
|
|
}
|
|
|
|
/* success */
|
|
return (STATUS_SUCCESS);
|
|
|
|
/* failure */
|
|
failProcess:
|
|
NtTerminateProcess
|
|
(
|
|
hProcess,
|
|
nErrCode
|
|
);
|
|
|
|
return (nErrCode);
|
|
}
|
|
|
|
/* EOF */
|
|
|