/*
* COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS/Win32 base enviroment subsystem server
+ * PROJECT: ReactOS/Win32 Base enviroment Subsystem Server
* FILE: subsystems/win/basesrv/server.c
- * PURPOSE: Initialization
+ * PURPOSE: Server APIs
* PROGRAMMERS: Hermes Belusca-Maito (hermes.belusca@sfr.fr)
*/
#define NDEBUG
#include <debug.h>
-
-extern NTSTATUS CallProcessCreated(PCSR_PROCESS, PCSR_PROCESS); // TODO: Import it from csrsrv/init.c
-
CSR_API(BaseSrvCreateProcess)
{
NTSTATUS Status;
+ PBASE_CREATE_PROCESS CreateProcessRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CreateProcessRequest;
HANDLE ProcessHandle, ThreadHandle;
PCSR_THREAD CsrThread;
- PCSR_PROCESS Process, NewProcess;
- ULONG Flags, VdmPower = 0, DebugFlags = 0;
+ PCSR_PROCESS Process;
+ ULONG Flags = 0, VdmPower = 0, DebugFlags = 0;
/* Get the current client thread */
CsrThread = CsrGetClientThread();
Process = CsrThread->Process;
/* Extract the flags out of the process handle */
- Flags = (ULONG_PTR)ApiMessage->Data.CreateProcessRequest.ProcessHandle & 3;
- ApiMessage->Data.CreateProcessRequest.ProcessHandle = (HANDLE)((ULONG_PTR)ApiMessage->Data.CreateProcessRequest.ProcessHandle & ~3);
+ Flags = (ULONG_PTR)CreateProcessRequest->ProcessHandle & 3;
+ CreateProcessRequest->ProcessHandle = (HANDLE)((ULONG_PTR)CreateProcessRequest->ProcessHandle & ~3);
/* Duplicate the process handle */
Status = NtDuplicateObject(Process->ProcessHandle,
- ApiMessage->Data.CreateProcessRequest.ProcessHandle,
+ CreateProcessRequest->ProcessHandle,
NtCurrentProcess(),
&ProcessHandle,
0,
/* Duplicate the thread handle */
Status = NtDuplicateObject(Process->ProcessHandle,
- ApiMessage->Data.CreateProcessRequest.ThreadHandle,
+ CreateProcessRequest->ThreadHandle,
NtCurrentProcess(),
&ThreadHandle,
0,
}
}
- /* Convert some flags. FIXME: More need conversion */
- if (ApiMessage->Data.CreateProcessRequest.CreationFlags & CREATE_NEW_PROCESS_GROUP)
+ /* Flags conversion. FIXME: More need conversion */
+ if (CreateProcessRequest->CreationFlags & CREATE_NEW_PROCESS_GROUP)
{
DebugFlags |= CsrProcessCreateNewGroup;
}
/* Call CSRSRV to create the CSR_PROCESS structure and the first CSR_THREAD */
Status = CsrCreateProcess(ProcessHandle,
ThreadHandle,
- &ApiMessage->Data.CreateProcessRequest.ClientId,
+ &CreateProcessRequest->ClientId,
Process->NtSession,
DebugFlags,
NULL);
if (Status == STATUS_THREAD_IS_TERMINATING)
{
DPRINT1("Thread already dead\n");
+
+ /* Set the special reply value so we don't reply this message back */
+ *ReplyCode = CsrReplyDeadClient;
+
return Status;
}
/* FIXME: VDM vodoo */
- /* ReactOS Compatibility */
- Status = CsrLockProcessByClientId(ApiMessage->Data.CreateProcessRequest.ClientId.UniqueProcess, &NewProcess);
- ASSERT(Status == STATUS_SUCCESS);
- if (!(ApiMessage->Data.CreateProcessRequest.CreationFlags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)))
- {
- NewProcess->ParentConsole = Process->Console;
- NewProcess->bInheritHandles = ApiMessage->Data.CreateProcessRequest.bInheritHandles;
- }
- RtlInitializeCriticalSection(&NewProcess->HandleTableLock);
- CallProcessCreated(Process, NewProcess);
- CsrUnlockProcess(NewProcess);
-
/* Return the result of this operation */
return Status;
}
CSR_API(BaseSrvCreateThread)
{
+ NTSTATUS Status;
+ PBASE_CREATE_THREAD CreateThreadRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CreateThreadRequest;
PCSR_THREAD CurrentThread;
HANDLE ThreadHandle;
- NTSTATUS Status;
PCSR_PROCESS CsrProcess;
/* Get the current CSR thread */
if (!CurrentThread)
{
DPRINT1("Server Thread TID: [%lx.%lx]\n",
- ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess,
- ApiMessage->Data.CreateThreadRequest.ClientId.UniqueThread);
+ CreateThreadRequest->ClientId.UniqueProcess,
+ CreateThreadRequest->ClientId.UniqueThread);
return STATUS_SUCCESS; // server-to-server
}
/* Get the CSR Process for this request */
CsrProcess = CurrentThread->Process;
if (CsrProcess->ClientId.UniqueProcess !=
- ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess)
+ CreateThreadRequest->ClientId.UniqueProcess)
{
/* This is a remote thread request -- is it within the server itself? */
- if (ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
+ if (CreateThreadRequest->ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
{
/* Accept this without any further work */
return STATUS_SUCCESS;
}
/* Get the real CSR Process for the remote thread's process */
- Status = CsrLockProcessByClientId(ApiMessage->Data.CreateThreadRequest.ClientId.UniqueProcess,
+ Status = CsrLockProcessByClientId(CreateThreadRequest->ClientId.UniqueProcess,
&CsrProcess);
if (!NT_SUCCESS(Status)) return Status;
}
/* Duplicate the thread handle so we can own it */
Status = NtDuplicateObject(CurrentThread->Process->ProcessHandle,
- ApiMessage->Data.CreateThreadRequest.ThreadHandle,
+ CreateThreadRequest->ThreadHandle,
NtCurrentProcess(),
&ThreadHandle,
0,
/* Call CSRSRV to tell it about the new thread */
Status = CsrCreateThread(CsrProcess,
ThreadHandle,
- &ApiMessage->Data.CreateThreadRequest.ClientId);
+ &CreateThreadRequest->ClientId,
+ TRUE);
}
/* Unlock the process and return */
CSR_API(BaseSrvGetTempFile)
{
static UINT CsrGetTempFileUnique = 0;
+ PBASE_GET_TEMP_FILE GetTempFile = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetTempFile;
/* Return 16-bits ID */
- ApiMessage->Data.GetTempFile.UniqueID = (++CsrGetTempFileUnique & 0xFFFF);
+ GetTempFile->UniqueID = (++CsrGetTempFileUnique & 0xFFFF);
- DPRINT("Returning: %u\n", ApiMessage->Data.GetTempFile.UniqueID);
+ DPRINT("Returning: %u\n", GetTempFile->UniqueID);
return STATUS_SUCCESS;
}
PCSR_THREAD CsrThread = CsrGetClientThread();
ASSERT(CsrThread != NULL);
- /* Set magic flag so we don't reply this message back */
- ApiMessage->ApiNumber = 0xBABE;
+ /* Set the special reply value so we don't reply this message back */
+ *ReplyCode = CsrReplyDeadClient;
/* Remove the CSR_THREADs and CSR_PROCESS */
return CsrDestroyProcess(&CsrThread->ClientId,
- (NTSTATUS)ApiMessage->Data.TerminateProcessRequest.uExitCode);
+ (NTSTATUS)((PBASE_API_MESSAGE)ApiMessage)->Data.ExitProcessRequest.uExitCode);
}
CSR_API(BaseSrvGetProcessShutdownParam)
{
+ PBASE_GET_PROCESS_SHUTDOWN_PARAMS GetShutdownParametersRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetShutdownParametersRequest;
PCSR_THREAD CsrThread = CsrGetClientThread();
ASSERT(CsrThread);
- ApiMessage->Data.GetShutdownParametersRequest.Level = CsrThread->Process->ShutdownLevel;
- ApiMessage->Data.GetShutdownParametersRequest.Flags = CsrThread->Process->ShutdownFlags;
+ GetShutdownParametersRequest->Level = CsrThread->Process->ShutdownLevel;
+ GetShutdownParametersRequest->Flags = CsrThread->Process->ShutdownFlags;
return STATUS_SUCCESS;
}
CSR_API(BaseSrvSetProcessShutdownParam)
{
+ PBASE_SET_PROCESS_SHUTDOWN_PARAMS SetShutdownParametersRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.SetShutdownParametersRequest;
PCSR_THREAD CsrThread = CsrGetClientThread();
ASSERT(CsrThread);
- CsrThread->Process->ShutdownLevel = ApiMessage->Data.SetShutdownParametersRequest.Level;
- CsrThread->Process->ShutdownFlags = ApiMessage->Data.SetShutdownParametersRequest.Flags;
+ CsrThread->Process->ShutdownLevel = SetShutdownParametersRequest->Level;
+ CsrThread->Process->ShutdownFlags = SetShutdownParametersRequest->Flags;
return STATUS_SUCCESS;
}
*** Dos Devices (C) Pierre Schweitzer (pierre.schweitzer@reactos.org)
***/
-typedef struct tagCSRSS_DOS_DEVICE_HISTORY_ENTRY
+typedef struct tagBASE_DOS_DEVICE_HISTORY_ENTRY
{
UNICODE_STRING Device;
UNICODE_STRING Target;
LIST_ENTRY Entry;
-} CSRSS_DOS_DEVICE_HISTORY_ENTRY, *PCSRSS_DOS_DEVICE_HISTORY_ENTRY;
+} BASE_DOS_DEVICE_HISTORY_ENTRY, *PBASE_DOS_DEVICE_HISTORY_ENTRY;
LIST_ENTRY DosDeviceHistory;
RTL_CRITICAL_SECTION BaseDefineDosDeviceCritSec;
+VOID BaseCleanupDefineDosDevice(VOID)
+{
+ PLIST_ENTRY Entry, ListHead;
+ PBASE_DOS_DEVICE_HISTORY_ENTRY HistoryEntry;
+
+ (void) RtlDeleteCriticalSection(&BaseDefineDosDeviceCritSec);
+
+ ListHead = &DosDeviceHistory;
+ Entry = ListHead->Flink;
+ while (Entry != ListHead)
+ {
+ HistoryEntry = (PBASE_DOS_DEVICE_HISTORY_ENTRY)
+ CONTAINING_RECORD(Entry,
+ BASE_DOS_DEVICE_HISTORY_ENTRY,
+ Entry);
+ Entry = Entry->Flink;
+
+ if (HistoryEntry)
+ {
+ if (HistoryEntry->Target.Buffer)
+ (void) RtlFreeHeap(BaseSrvHeap,
+ 0,
+ HistoryEntry->Target.Buffer);
+ if (HistoryEntry->Device.Buffer)
+ (void) RtlFreeHeap(BaseSrvHeap,
+ 0,
+ HistoryEntry->Device.Buffer);
+ (void) RtlFreeHeap(BaseSrvHeap,
+ 0,
+ HistoryEntry);
+ }
+ }
+}
+
CSR_API(BaseSrvDefineDosDevice)
{
+ NTSTATUS Status;
+ PBASE_DEFINE_DOS_DEVICE DefineDosDeviceRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.DefineDosDeviceRequest;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE LinkHandle = NULL;
- NTSTATUS Status;
UNICODE_STRING DeviceName = {0};
UNICODE_STRING RequestDeviceName = {0};
UNICODE_STRING LinkTarget = {0};
PSID SystemSid;
PSID WorldSid;
ULONG SidLength;
- PCSRSS_DOS_DEVICE_HISTORY_ENTRY HistoryEntry;
+ PBASE_DOS_DEVICE_HISTORY_ENTRY HistoryEntry;
PLIST_ENTRY Entry;
PLIST_ENTRY ListHead;
BOOLEAN Matched, AddHistory;
PWSTR lpBuffer;
DPRINT("CsrDefineDosDevice entered, Flags:%d, DeviceName:%wZ, TargetName:%wZ\n",
- ApiMessage->Data.DefineDosDeviceRequest.dwFlags,
- &ApiMessage->Data.DefineDosDeviceRequest.DeviceName,
- &ApiMessage->Data.DefineDosDeviceRequest.TargetName);
+ DefineDosDeviceRequest->dwFlags,
+ &DefineDosDeviceRequest->DeviceName,
+ &DefineDosDeviceRequest->TargetName);
Matched = AddHistory = FALSE;
HistoryEntry = NULL;
AdminSid = SystemSid = WorldSid = NULL;
SecurityDescriptor = NULL;
ListHead = &DosDeviceHistory;
- dwFlags = ApiMessage->Data.DefineDosDeviceRequest.dwFlags;
+ dwFlags = DefineDosDeviceRequest->dwFlags;
/* Validate the flags */
if ( (dwFlags & 0xFFFFFFF0) ||
{
Status =
RtlUpcaseUnicodeString(&RequestDeviceName,
- &ApiMessage->Data.DefineDosDeviceRequest.DeviceName,
+ &DefineDosDeviceRequest->DeviceName,
TRUE);
if (! NT_SUCCESS(Status))
_SEH2_LEAVE;
- RequestLinkTarget =
- &ApiMessage->Data.DefineDosDeviceRequest.TargetName;
- lpBuffer = (PWSTR) RtlAllocateHeap(Win32CsrApiHeap,
+ RequestLinkTarget = &DefineDosDeviceRequest->TargetName;
+ lpBuffer = (PWSTR) RtlAllocateHeap(BaseSrvHeap,
HEAP_ZERO_MEMORY,
RequestDeviceName.MaximumLength + 5 * sizeof(WCHAR));
if (! lpBuffer)
LinkTarget.Length = 0;
LinkTarget.MaximumLength = Length;
LinkTarget.Buffer = (PWSTR)
- RtlAllocateHeap(Win32CsrApiHeap,
+ RtlAllocateHeap(BaseSrvHeap,
HEAP_ZERO_MEMORY,
Length);
if (! LinkTarget.Buffer)
Entry = ListHead->Flink;
while (Entry != ListHead)
{
- HistoryEntry = (PCSRSS_DOS_DEVICE_HISTORY_ENTRY)
+ HistoryEntry = (PBASE_DOS_DEVICE_HISTORY_ENTRY)
CONTAINING_RECORD(Entry,
- CSRSS_DOS_DEVICE_HISTORY_ENTRY,
+ BASE_DOS_DEVICE_HISTORY_ENTRY,
Entry);
Matched =
! RtlCompareUnicodeString(&RequestDeviceName,
Entry = ListHead->Flink;
while (Entry != ListHead)
{
- HistoryEntry = (PCSRSS_DOS_DEVICE_HISTORY_ENTRY)
+ HistoryEntry = (PBASE_DOS_DEVICE_HISTORY_ENTRY)
CONTAINING_RECORD(Entry,
- CSRSS_DOS_DEVICE_HISTORY_ENTRY,
+ BASE_DOS_DEVICE_HISTORY_ENTRY,
Entry);
Matched =
! RtlCompareUnicodeString(&RequestDeviceName,
if (AddHistory)
{
- HistoryEntry = (PCSRSS_DOS_DEVICE_HISTORY_ENTRY)
- RtlAllocateHeap(Win32CsrApiHeap,
+ HistoryEntry = (PBASE_DOS_DEVICE_HISTORY_ENTRY)
+ RtlAllocateHeap(BaseSrvHeap,
HEAP_ZERO_MEMORY,
- sizeof(CSRSS_DOS_DEVICE_HISTORY_ENTRY));
+ sizeof(BASE_DOS_DEVICE_HISTORY_ENTRY));
if (! HistoryEntry)
{
DPRINT1("Failed to allocate memory\n");
}
HistoryEntry->Target.Buffer =
- RtlAllocateHeap(Win32CsrApiHeap,
+ RtlAllocateHeap(BaseSrvHeap,
HEAP_ZERO_MEMORY,
LinkTarget.Length);
if (! HistoryEntry->Target.Buffer)
&LinkTarget);
HistoryEntry->Device.Buffer =
- RtlAllocateHeap(Win32CsrApiHeap,
+ RtlAllocateHeap(BaseSrvHeap,
HEAP_ZERO_MEMORY,
RequestDeviceName.Length);
if (! HistoryEntry->Device.Buffer)
RtlLengthSid(WorldSid);
Length = sizeof(ACL) + SidLength + 3 * sizeof(ACCESS_ALLOWED_ACE);
- SecurityDescriptor = RtlAllocateHeap(Win32CsrApiHeap,
+ SecurityDescriptor = RtlAllocateHeap(BaseSrvHeap,
0,
SECURITY_DESCRIPTOR_MIN_LENGTH + Length);
if (! SecurityDescriptor)
{
(void) RtlLeaveCriticalSection(&BaseDefineDosDeviceCritSec);
if (DeviceName.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
DeviceName.Buffer);
if (LinkTarget.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
LinkTarget.Buffer);
if (SecurityDescriptor)
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
SecurityDescriptor);
if (LinkHandle)
if (HistoryEntry)
{
if (HistoryEntry->Target.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
HistoryEntry->Target.Buffer);
if (HistoryEntry->Device.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
HistoryEntry->Device.Buffer);
- (void) RtlFreeHeap(Win32CsrApiHeap,
+ (void) RtlFreeHeap(BaseSrvHeap,
0,
HistoryEntry);
}
return Status;
}
-VOID BaseCleanupDefineDosDevice(VOID)
-{
- PLIST_ENTRY Entry, ListHead;
- PCSRSS_DOS_DEVICE_HISTORY_ENTRY HistoryEntry;
-
- (void) RtlDeleteCriticalSection(&BaseDefineDosDeviceCritSec);
-
- ListHead = &DosDeviceHistory;
- Entry = ListHead->Flink;
- while (Entry != ListHead)
- {
- HistoryEntry = (PCSRSS_DOS_DEVICE_HISTORY_ENTRY)
- CONTAINING_RECORD(Entry,
- CSRSS_DOS_DEVICE_HISTORY_ENTRY,
- Entry);
- Entry = Entry->Flink;
-
- if (HistoryEntry)
- {
- if (HistoryEntry->Target.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
- 0,
- HistoryEntry->Target.Buffer);
- if (HistoryEntry->Device.Buffer)
- (void) RtlFreeHeap(Win32CsrApiHeap,
- 0,
- HistoryEntry->Device.Buffer);
- (void) RtlFreeHeap(Win32CsrApiHeap,
- 0,
- HistoryEntry);
- }
- }
-}
-
projects / reactos.git / blobdiff