From b0bac13ce1f379a5733dd139214427fdddcf0c4c Mon Sep 17 00:00:00 2001 From: Alex Ionescu Date: Wed, 7 Sep 2005 19:37:28 +0000 Subject: [PATCH] Implement NTDLL's CSR routines in a compatible way. Fix prototypes, argument count, deprecated functions and new functions. Some functions will not work (or are designed not to work) fully until the new CSR is committed, but they keep the same functionality as the previous versions (no regressions found; tested with cmd, cmt, putty, telnet, ps). Also added NtSecureConnectPort. svn path=/trunk/; revision=17727 --- reactos/include/ndk/umfuncs.h | 55 ++-- reactos/include/ndk/zwfuncs.h | 31 ++ reactos/include/subsys/csrss/csrss.h | 72 +++++ reactos/lib/kernel32/misc/console.c | 227 ++++++++------ reactos/lib/kernel32/misc/dllmain.c | 63 ++-- reactos/lib/ntdll/csr/api.c | 89 ++++++ reactos/lib/ntdll/csr/capture.c | 307 ++++++++++++++----- reactos/lib/ntdll/csr/connect.c | 430 +++++++++++++++++++++++++++ reactos/lib/ntdll/csr/lpc.c | 194 ------------ reactos/lib/ntdll/csr/probe.c | 66 ---- reactos/lib/ntdll/csr/srv.c | 25 -- reactos/lib/ntdll/csr/thread.c | 60 ---- reactos/lib/ntdll/def/ntdll.def | 10 +- reactos/lib/ntdll/ntdll.xml | 6 +- reactos/subsys/csrss/init.c | 6 +- reactos/tools/nci/sysfuncs.lst | 1 + 16 files changed, 1083 insertions(+), 559 deletions(-) create mode 100644 reactos/lib/ntdll/csr/api.c create mode 100644 reactos/lib/ntdll/csr/connect.c delete mode 100644 reactos/lib/ntdll/csr/lpc.c delete mode 100644 reactos/lib/ntdll/csr/probe.c delete mode 100644 reactos/lib/ntdll/csr/srv.c delete mode 100644 reactos/lib/ntdll/csr/thread.c diff --git a/reactos/include/ndk/umfuncs.h b/reactos/include/ndk/umfuncs.h index d4d1420a5c2..1ff23c84008 100644 --- a/reactos/include/ndk/umfuncs.h +++ b/reactos/include/ndk/umfuncs.h @@ -8,29 +8,53 @@ #define _UMFUNCS_H /* DEPENDENCIES **************************************************************/ +struct _CSR_API_MESSAGE; +struct _CSR_CAPTURE_BUFFER; /* PROTOTYPES ****************************************************************/ /* * CSR Functions */ +PVOID +NTAPI +CsrAllocateCaptureBuffer( + ULONG ArgumentCount, + ULONG BufferSize +); + +ULONG +NTAPI +CsrAllocateMessagePointer( + struct _CSR_CAPTURE_BUFFER *CaptureBuffer, + ULONG MessageLength, + PVOID *CaptureData +); + +VOID +NTAPI +CsrCaptureMessageBuffer( + struct _CSR_CAPTURE_BUFFER *CaptureBuffer, + PVOID MessageString, + ULONG StringLength, + PVOID *CapturedData +); + NTSTATUS NTAPI CsrClientConnectToServer( PWSTR ObjectDirectory, ULONG ServerId, - PVOID Unknown, - PVOID Context, - ULONG ContextLength, + PVOID ConnectionInfo, + PULONG ConnectionInfoSize, PBOOLEAN ServerToServerCall ); -struct _CSR_API_MESSAGE; NTSTATUS NTAPI CsrClientCallServer( struct _CSR_API_MESSAGE *Request, - PVOID CapturedBuffer OPTIONAL, + struct _CSR_CAPTURE_BUFFER *CaptureBuffer OPTIONAL, ULONG ApiNumber, ULONG RequestLength ); @@ -39,6 +63,10 @@ NTSTATUS NTAPI CsrIdentifyAlertableThread(VOID); +VOID +NTAPI +CsrFreeCaptureBuffer(struct _CSR_CAPTURE_BUFFER *CaptureBuffer); + NTSTATUS NTAPI CsrNewThread(VOID); @@ -53,7 +81,7 @@ CsrSetPriorityClass( VOID NTAPI CsrProbeForRead( - IN CONST PVOID Address, + IN PVOID Address, IN ULONG Length, IN ULONG Alignment ); @@ -61,24 +89,11 @@ CsrProbeForRead( VOID NTAPI CsrProbeForWrite( - IN CONST PVOID Address, + IN PVOID Address, IN ULONG Length, IN ULONG Alignment ); -NTSTATUS -NTAPI -CsrCaptureParameterBuffer( - PVOID ParameterBuffer, - ULONG ParameterBufferSize, - PVOID* ClientAddress, - PVOID* ServerAddress -); - -NTSTATUS -NTAPI -CsrReleaseParameterBuffer(PVOID ClientAddress); - /* * Debug Functions */ diff --git a/reactos/include/ndk/zwfuncs.h b/reactos/include/ndk/zwfuncs.h index 7f958682146..d5fd8c57782 100644 --- a/reactos/include/ndk/zwfuncs.h +++ b/reactos/include/ndk/zwfuncs.h @@ -3322,6 +3322,37 @@ ZwSaveKeyEx( IN ULONG Flags ); + +NTSYSCALLAPI +NTSTATUS +NTAPI +NtSecureConnectPort( + PHANDLE PortHandle, + PUNICODE_STRING PortName, + PSECURITY_QUALITY_OF_SERVICE SecurityQos, + PPORT_VIEW ClientView OPTIONAL, + PSID Sid OPTIONAL, + PREMOTE_PORT_VIEW ServerView OPTIONAL, + PULONG MaxMessageLength OPTIONAL, + PVOID ConnectionInformation OPTIONAL, + PULONG ConnectionInformationLength OPTIONAL +); + +NTSYSAPI +NTSTATUS +NTAPI +ZwSecureConnectPort( + PHANDLE PortHandle, + PUNICODE_STRING PortName, + PSECURITY_QUALITY_OF_SERVICE SecurityQos, + PPORT_VIEW ClientView OPTIONAL, + PSID Sid OPTIONAL, + PREMOTE_PORT_VIEW ServerView OPTIONAL, + PULONG MaxMessageLength OPTIONAL, + PVOID ConnectionInformation OPTIONAL, + PULONG ConnectionInformationLength OPTIONAL +); + NTSTATUS NTAPI NtSetBootEntryOrder( diff --git a/reactos/include/subsys/csrss/csrss.h b/reactos/include/subsys/csrss/csrss.h index 130960dc5ed..9a018baa9a5 100644 --- a/reactos/include/subsys/csrss/csrss.h +++ b/reactos/include/subsys/csrss/csrss.h @@ -484,6 +484,7 @@ typedef struct typedef struct _CSR_API_MESSAGE { PORT_MESSAGE Header; + PVOID CsrCaptureData; ULONG Type; NTSTATUS Status; union @@ -544,4 +545,75 @@ typedef struct _CSR_API_MESSAGE } Data; } CSR_API_MESSAGE, *PCSR_API_MESSAGE; +/* Types used in the new CSR. Temporarly here for proper compile of NTDLL */ +#define CSR_SRV_SERVER 0 + +#define CsrSrvClientConnect 0 +#define CsrSrvIdentifyAlertableThread 3 +#define CsrSrvSetPriorityClass 4 + +#define CSR_MAKE_OPCODE(s,m) ((s) << 16) | (m) + +typedef struct _CSR_CONNECTION_INFO +{ + ULONG Version; + ULONG Unknown; + HANDLE ObjectDirectory; + PVOID SharedSectionBase; + PVOID SharedSectionHeap; + PVOID SharedSectionData; + ULONG DebugFlags; + ULONG Unknown2[3]; + HANDLE ProcessId; +} CSR_CONNECTION_INFO, *PCSR_CONNECTION_INFO; + +typedef struct _CSR_CLIENT_CONNECT +{ + ULONG ServerId; + PVOID ConnectionInfo; + ULONG ConnectionInfoSize; +} CSR_CLIENT_CONNECT, *PCSR_CLIENT_CONNECT; + +typedef struct _CSR_IDENTIFY_ALTERTABLE_THREAD +{ + CLIENT_ID Cid; +} CSR_IDENTIFY_ALTERTABLE_THREAD, *PCSR_IDENTIFY_ALTERTABLE_THREAD; + +typedef struct _CSR_SET_PRIORITY_CLASS +{ + HANDLE hProcess; + ULONG PriorityClass; +} CSR_SET_PRIORITY_CLASS, *PCSR_SET_PRIORITY_CLASS; + +typedef struct _CSR_API_MESSAGE2 +{ + PORT_MESSAGE Header; + union + { + CSR_CONNECTION_INFO ConnectionInfo; + struct + { + PVOID CsrCaptureData; + CSR_API_NUMBER Opcode; + ULONG Status; + ULONG Reserved; + union + { + CSR_CLIENT_CONNECT ClientConnect; + CSR_SET_PRIORITY_CLASS SetPriorityClass; + CSR_IDENTIFY_ALTERTABLE_THREAD IdentifyAlertableThread; + }; + }; + }; +} CSR_API_MESSAGE2, *PCSR_API_MESSAGE2; + +typedef struct _CSR_CAPTURE_BUFFER +{ + ULONG Size; + struct _CSR_CAPTURE_BUFFER *PreviousCaptureBuffer; + ULONG PointerCount; + ULONG_PTR BufferEnd; + ULONG_PTR PointerArray[1]; +} CSR_CAPTURE_BUFFER, *PCSR_CAPTURE_BUFFER; + #endif /* __INCLUDE_CSRSS_CSRSS_H */ diff --git a/reactos/lib/kernel32/misc/console.c b/reactos/lib/kernel32/misc/console.c index cfa9ec16dc3..c36154103e7 100644 --- a/reactos/lib/kernel32/misc/console.c +++ b/reactos/lib/kernel32/misc/console.c @@ -1546,8 +1546,8 @@ IntPeekConsoleInput(HANDLE hConsoleInput, BOOL bUnicode) { CSR_API_MESSAGE Request; ULONG CsrRequest; + PCSR_CAPTURE_BUFFER CaptureBuffer; NTSTATUS Status; - PVOID BufferBase; PVOID BufferTargetBase; ULONG Size; @@ -1559,40 +1559,55 @@ IntPeekConsoleInput(HANDLE hConsoleInput, Size = nLength * sizeof(INPUT_RECORD); - Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + /* Allocate a Capture Buffer */ + DPRINT1("IntPeekConsoleInput: %lx %p\n", Size, lpNumberOfEventsRead); + CaptureBuffer = CsrAllocateCaptureBuffer(1, Size); + /* Allocate space in the Buffer */ + CsrCaptureMessageBuffer(CaptureBuffer, NULL, Size, &BufferTargetBase); + DPRINT1("Allocated message buffer: %p %p\n", CaptureBuffer, BufferTargetBase); + + /* Set up the data to send to the Console Server */ CsrRequest = MAKE_CSR_API(PEEK_CONSOLE_INPUT, CSR_CONSOLE); Request.Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput; Request.Data.PeekConsoleInputRequest.Unicode = bUnicode; Request.Data.PeekConsoleInputRequest.Length = nLength; Request.Data.PeekConsoleInputRequest.InputRecord = (INPUT_RECORD*)BufferTargetBase; + /* Call the server */ + DPRINT1("Calling Server\n"); Status = CsrClientCallServer(&Request, - NULL, + CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE)); + DPRINT1("Server returned: %x\n", Request.Status); - if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status)) - { - CsrReleaseParameterBuffer(BufferBase); - return FALSE; - } - - memcpy(lpBuffer, BufferBase, sizeof(INPUT_RECORD) * Request.Data.PeekConsoleInputRequest.Length); - - CsrReleaseParameterBuffer(BufferBase); - - if(lpNumberOfEventsRead != NULL) + /* Check for success*/ + if (NT_SUCCESS(Request.Status)) { + /* Return the number of events read */ + DPRINT1("Events read: %lx\n", Request.Data.PeekConsoleInputRequest.Length); *lpNumberOfEventsRead = Request.Data.PeekConsoleInputRequest.Length; + + /* Copy into the buffer */ + DPRINT1("Copying to buffer\n"); + RtlCopyMemory(lpBuffer, + Request.Data.PeekConsoleInputRequest.InputRecord, + sizeof(INPUT_RECORD) * *lpNumberOfEventsRead); + } + else + { + /* Error out */ + *lpNumberOfEventsRead = 0; + SetLastErrorByStatus(Request.Status); } - return TRUE; + /* Release the capture buffer */ + DPRINT1("Release buffer and return\n"); + CsrFreeCaptureBuffer(CaptureBuffer); + + /* Return TRUE or FALSE */ + return NT_SUCCESS(Request.Status); } /*-------------------------------------------------------------- @@ -1751,8 +1766,8 @@ IntWriteConsoleInput(HANDLE hConsoleInput, BOOL bUnicode) { CSR_API_MESSAGE Request; ULONG CsrRequest; - - PVOID BufferBase, BufferTargetBase; + PCSR_CAPTURE_BUFFER CaptureBuffer; + PVOID BufferTargetBase; NTSTATUS Status; DWORD Size; @@ -1764,37 +1779,55 @@ IntWriteConsoleInput(HANDLE hConsoleInput, Size = nLength * sizeof(INPUT_RECORD); - Status = CsrCaptureParameterBuffer((PVOID)lpBuffer, Size, &BufferBase, &BufferTargetBase); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + /* Allocate a Capture Buffer */ + DPRINT1("IntWriteConsoleInput: %lx %p\n", Size, lpNumberOfEventsWritten); + CaptureBuffer = CsrAllocateCaptureBuffer(1, Size); + /* Allocate space in the Buffer */ + CsrCaptureMessageBuffer(CaptureBuffer, NULL, Size, &BufferTargetBase); + DPRINT1("Allocated message buffer: %p %p\n", CaptureBuffer, BufferTargetBase); + + /* Set up the data to send to the Console Server */ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_INPUT, CSR_CONSOLE); Request.Data.WriteConsoleInputRequest.ConsoleHandle = hConsoleInput; Request.Data.WriteConsoleInputRequest.Unicode = bUnicode; Request.Data.WriteConsoleInputRequest.Length = nLength; Request.Data.WriteConsoleInputRequest.InputRecord = (PINPUT_RECORD)BufferTargetBase; - Status = CsrClientCallServer(&Request, NULL, + /* Call the server */ + DPRINT1("Calling Server\n"); + Status = CsrClientCallServer(&Request, + CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE)); + DPRINT1("Server returned: %x\n", Request.Status); - CsrReleaseParameterBuffer(BufferBase); - - if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - - if(lpNumberOfEventsWritten != NULL) + /* Check for success*/ + if (NT_SUCCESS(Request.Status)) { + /* Return the number of events read */ + DPRINT1("Events read: %lx\n", Request.Data.WriteConsoleInputRequest.Length); *lpNumberOfEventsWritten = Request.Data.WriteConsoleInputRequest.Length; + + /* Copy into the buffer */ + DPRINT1("Copying to buffer\n"); + RtlCopyMemory(lpBuffer, + Request.Data.WriteConsoleInputRequest.InputRecord, + sizeof(INPUT_RECORD) * *lpNumberOfEventsWritten); + } + else + { + /* Error out */ + *lpNumberOfEventsWritten = 0; + SetLastErrorByStatus(Request.Status); } - return TRUE; + /* Release the capture buffer */ + DPRINT1("Release buffer and return\n"); + CsrFreeCaptureBuffer(CaptureBuffer); + + /* Return TRUE or FALSE */ + return NT_SUCCESS(Request.Status); } @@ -1851,8 +1884,7 @@ IntReadConsoleOutput(HANDLE hConsoleOutput, BOOL bUnicode) { CSR_API_MESSAGE Request; ULONG CsrRequest; - - PVOID BufferBase; + PCSR_CAPTURE_BUFFER CaptureBuffer; PVOID BufferTargetBase; NTSTATUS Status; DWORD Size, SizeX, SizeY; @@ -1865,13 +1897,15 @@ IntReadConsoleOutput(HANDLE hConsoleOutput, Size = dwBufferSize.X * dwBufferSize.Y * sizeof(CHAR_INFO); - Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + /* Allocate a Capture Buffer */ + DPRINT1("IntReadConsoleOutput: %lx %p\n", Size, lpReadRegion); + CaptureBuffer = CsrAllocateCaptureBuffer(1, Size); + /* Allocate space in the Buffer */ + CsrCaptureMessageBuffer(CaptureBuffer, NULL, Size, &BufferTargetBase); + DPRINT1("Allocated message buffer: %p %p\n", CaptureBuffer, BufferTargetBase); + + /* Set up the data to send to the Console Server */ CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT, CSR_CONSOLE); Request.Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput; Request.Data.ReadConsoleOutputRequest.Unicode = bUnicode; @@ -1880,28 +1914,43 @@ IntReadConsoleOutput(HANDLE hConsoleOutput, Request.Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion; Request.Data.ReadConsoleOutputRequest.CharInfo = (PCHAR_INFO)BufferTargetBase; + /* Call the server */ + DPRINT1("Calling Server\n"); Status = CsrClientCallServer(&Request, - NULL, + CaptureBuffer, CsrRequest, sizeof(CSR_API_MESSAGE)); + DPRINT1("Server returned: %x\n", Request.Status); - if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status)) + /* Check for success*/ + if (NT_SUCCESS(Request.Status)) { - SetLastErrorByStatus(Status); - CsrReleaseParameterBuffer(BufferBase); - return FALSE; + /* Copy into the buffer */ + DPRINT1("Copying to buffer\n"); + SizeX = Request.Data.ReadConsoleOutputRequest.ReadRegion.Right - + Request.Data.ReadConsoleOutputRequest.ReadRegion.Left + 1; + SizeY = Request.Data.ReadConsoleOutputRequest.ReadRegion.Bottom - + Request.Data.ReadConsoleOutputRequest.ReadRegion.Top + 1; + RtlCopyMemory(lpBuffer, + Request.Data.ReadConsoleOutputRequest.CharInfo, + sizeof(CHAR_INFO) * SizeX * SizeY); + } + else + { + /* Error out */ + SetLastErrorByStatus(Request.Status); } - SizeX = Request.Data.ReadConsoleOutputRequest.ReadRegion.Right - Request.Data.ReadConsoleOutputRequest.ReadRegion.Left + 1; - SizeY = Request.Data.ReadConsoleOutputRequest.ReadRegion.Bottom - Request.Data.ReadConsoleOutputRequest.ReadRegion.Top + 1; - - memcpy(lpBuffer, BufferBase, sizeof(CHAR_INFO) * SizeX * SizeY); - - CsrReleaseParameterBuffer(BufferBase); - + /* Return the read region */ + DPRINT1("read region: %lx\n", Request.Data.ReadConsoleOutputRequest.ReadRegion); *lpReadRegion = Request.Data.ReadConsoleOutputRequest.ReadRegion; - return TRUE; + /* Release the capture buffer */ + DPRINT1("Release buffer and return\n"); + CsrFreeCaptureBuffer(CaptureBuffer); + + /* Return TRUE or FALSE */ + return NT_SUCCESS(Request.Status); } /*-------------------------------------------------------------- @@ -1953,49 +2002,59 @@ IntWriteConsoleOutput(HANDLE hConsoleOutput, BOOL bUnicode) { CSR_API_MESSAGE Request; ULONG CsrRequest; + PCSR_CAPTURE_BUFFER CaptureBuffer; NTSTATUS Status; ULONG Size; - PVOID BufferBase; PVOID BufferTargetBase; Size = dwBufferSize.Y * dwBufferSize.X * sizeof(CHAR_INFO); - Status = CsrCaptureParameterBuffer((PVOID)lpBuffer, - Size, - &BufferBase, - &BufferTargetBase); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return(FALSE); - } + /* Allocate a Capture Buffer */ + DPRINT1("IntWriteConsoleOutput: %lx %p\n", Size, lpWriteRegion); + CaptureBuffer = CsrAllocateCaptureBuffer(1, Size); + /* Allocate space in the Buffer */ + CsrCaptureMessageBuffer(CaptureBuffer, NULL, Size, &BufferTargetBase); + DPRINT1("Allocated message buffer: %p %p\n", CaptureBuffer, BufferTargetBase); + + /* Copy from the buffer */ + DPRINT1("Copying into buffer\n"); + RtlCopyMemory(BufferTargetBase, lpBuffer, Size); + + /* Set up the data to send to the Console Server */ CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT, CSR_CONSOLE); Request.Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput; Request.Data.WriteConsoleOutputRequest.Unicode = bUnicode; Request.Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize; Request.Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord; Request.Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion; - Request.Data.WriteConsoleOutputRequest.CharInfo = - (CHAR_INFO*)BufferTargetBase; + Request.Data.WriteConsoleOutputRequest.CharInfo = (CHAR_INFO*)BufferTargetBase; + /* Call the server */ + DPRINT1("Calling Server\n"); Status = CsrClientCallServer(&Request, - NULL, - CsrRequest, - sizeof(CSR_API_MESSAGE)); + CaptureBuffer, + CsrRequest, + sizeof(CSR_API_MESSAGE)); + DPRINT1("Server returned: %x\n", Request.Status); - if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status)) - { - CsrReleaseParameterBuffer(BufferBase); - SetLastErrorByStatus(Status); - return FALSE; - } - - CsrReleaseParameterBuffer(BufferBase); + /* Check for success*/ + if (!NT_SUCCESS(Request.Status)) + { + /* Error out */ + SetLastErrorByStatus(Request.Status); + } + /* Return the read region */ + DPRINT1("read region: %lx\n", Request.Data.WriteConsoleOutputRequest.WriteRegion); *lpWriteRegion = Request.Data.WriteConsoleOutputRequest.WriteRegion; - return(TRUE); + /* Release the capture buffer */ + DPRINT1("Release buffer and return\n"); + CsrFreeCaptureBuffer(CaptureBuffer); + + /* Return TRUE or FALSE */ + return NT_SUCCESS(Request.Status); } /*-------------------------------------------------------------- diff --git a/reactos/lib/kernel32/misc/dllmain.c b/reactos/lib/kernel32/misc/dllmain.c index 53ed5666adc..03033b761b2 100644 --- a/reactos/lib/kernel32/misc/dllmain.c +++ b/reactos/lib/kernel32/misc/dllmain.c @@ -16,6 +16,8 @@ #define NDEBUG #include "../include/debug.h" +#define CSR_BASE_DLL 0 // <- This should be 1 when CSR gets committed + /* GLOBALS *******************************************************************/ extern UNICODE_STRING SystemDirectory; @@ -198,41 +200,46 @@ BasepInitConsole(VOID) } -BOOL STDCALL +BOOL +STDCALL DllMain(HANDLE hDll, - DWORD dwReason, - LPVOID lpReserved) + DWORD dwReason, + LPVOID lpReserved) { - NTSTATUS Status; + NTSTATUS Status; + BOOLEAN IsServer; + ULONG Dummy; + ULONG DummySize = sizeof(Dummy); - (void)lpReserved; + DPRINT("DllMain(hInst %lx, dwReason %lu)\n", + hDll, dwReason); - DPRINT("DllMain(hInst %lx, dwReason %lu)\n", - hDll, dwReason); - - switch (dwReason) + switch (dwReason) { - case DLL_PROCESS_ATTACH: - DPRINT("DLL_PROCESS_ATTACH\n"); + case DLL_PROCESS_ATTACH: - LdrDisableThreadCalloutsForDll ((PVOID)hDll); + /* Don't bother us for each thread */ + LdrDisableThreadCalloutsForDll((PVOID)hDll); - /* - * Connect to the csrss server - */ - Status = CsrClientConnectToServer(L"\\Windows\\ApiPort", - 0, - NULL, - NULL, - 0, - NULL); - if (!NT_SUCCESS(Status)) - { - DbgPrint("Failed to connect to csrss.exe (Status %lx)\n", - Status); - ZwTerminateProcess(NtCurrentProcess(), Status); - return FALSE; - } + /* Connect to the base server */ + Status = CsrClientConnectToServer(L"\\Windows", // <- FIXME: SessionDir + CSR_BASE_DLL, + &Dummy, + &DummySize, + &IsServer); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Failed to connect to CSR (Status %lx)\n", Status); + ZwTerminateProcess(NtCurrentProcess(), Status); + return FALSE; + } + + /* Check if we are running a CSR Server */ + if (!IsServer) + { + /* Set the termination port for the thread */ + CsrNewThread(); + } hProcessHeap = RtlGetProcessHeap(); hCurrentModule = hDll; diff --git a/reactos/lib/ntdll/csr/api.c b/reactos/lib/ntdll/csr/api.c new file mode 100644 index 00000000000..759019d75f7 --- /dev/null +++ b/reactos/lib/ntdll/csr/api.c @@ -0,0 +1,89 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: lib/ntdll/csr/api.c + * PURPOSE: CSR APIs exported through NTDLL + * PROGRAMMER: Alex Ionescu (alex@relsoft.net) + */ + +/* INCLUDES *****************************************************************/ + +#include +#define NDEBUG +#include + +/* GLOBALS *******************************************************************/ +extern HANDLE CsrApiPort; + +/* FUNCTIONS *****************************************************************/ + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrNewThread(VOID) +{ + /* Register the termination port to CSR's */ + return NtRegisterThreadTerminatePort(CsrApiPort); +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrSetPriorityClass(HANDLE hProcess, + PULONG PriorityClass) +{ + NTSTATUS Status; + CSR_API_MESSAGE2 ApiMessage; /* <- Remove the "2" when CSR is commited */ + PCSR_SET_PRIORITY_CLASS SetPriorityClass = &ApiMessage.SetPriorityClass; + + /* Set up the data for CSR */ + DbgBreakPoint(); + SetPriorityClass->hProcess = hProcess; + SetPriorityClass->PriorityClass = *PriorityClass; + + /* Call it */ + Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage, + NULL, + CSR_MAKE_OPCODE(CsrSrvSetPriorityClass, + CSR_SRV_SERVER), + sizeof(CSR_SET_PRIORITY_CLASS)); + + /* Return what we got, if requested */ + if (*PriorityClass) *PriorityClass = SetPriorityClass->PriorityClass; + + /* Return to caller */ + return Status; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrIdentifyAlertableThread (VOID) +{ + NTSTATUS Status; + CSR_API_MESSAGE2 ApiMessage; /* <- Remove the "2" when CSR is commited */ + PCSR_IDENTIFY_ALTERTABLE_THREAD IdentifyAlertableThread; + + /* Set up the data for CSR */ + DbgBreakPoint(); + IdentifyAlertableThread = &ApiMessage.IdentifyAlertableThread; + IdentifyAlertableThread->Cid = NtCurrentTeb()->Cid; + + /* Call it */ + Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage, + NULL, + CSR_MAKE_OPCODE(CsrSrvIdentifyAlertableThread, + CSR_SRV_SERVER), + sizeof(CSR_SET_PRIORITY_CLASS)); + + /* Return to caller */ + return Status; +} + +/* EOF */ diff --git a/reactos/lib/ntdll/csr/capture.c b/reactos/lib/ntdll/csr/capture.c index 7760b63d62f..5534ffec80c 100644 --- a/reactos/lib/ntdll/csr/capture.c +++ b/reactos/lib/ntdll/csr/capture.c @@ -1,9 +1,9 @@ -/* $Id$ - * +/* * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel * FILE: lib/ntdll/csr/capture.c - * PURPOSE: CSRSS Capture API + * PURPOSE: routines for probing and capturing CSR API Messages + * PROGRAMMER: Alex Ionescu (alex@relsoft.net) */ /* INCLUDES *****************************************************************/ @@ -13,90 +13,255 @@ #include /* GLOBALS *******************************************************************/ - -static HANDLE hCaptureHeap = INVALID_HANDLE_VALUE; /* FIXME: use the general NTDLL heap */ +extern HANDLE CsrPortHeap; /* FUNCTIONS *****************************************************************/ /* - * @unimplemented + * @implemented */ -PVOID -STDCALL CsrAllocateCaptureBuffer ( - DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2 - ) +VOID +NTAPI +CsrProbeForRead(IN PVOID Address, + IN ULONG Length, + IN ULONG Alignment) { - /* FIXME: implement it! */ - return NULL; -} + PUCHAR Pointer; + UCHAR Data; -/* - * @unimplemented - */ -VOID STDCALL -CsrCaptureMessageString (DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2, - DWORD Unknown3, - DWORD Unknown4) -{ -} + /* Validate length */ + if (Length == 0) return; -/* - * @unimplemented - */ -VOID STDCALL -CsrAllocateCapturePointer(ULONG Unknown0, - ULONG Unknown1, - ULONG Unknown2) -{ + /* Validate alignment */ + if ((ULONG_PTR)Address & (Alignment - 1)) + { + /* Raise exception if it doesn't match */ + RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT); + } -} - -/* - * @unimplemented - */ -VOID STDCALL CsrAllocateMessagePointer (DWORD Unknown0, - DWORD Unknown1, - DWORD Unknown2) -{ -} - -/* - * @unimplemented - */ -VOID STDCALL -CsrCaptureMessageBuffer(ULONG Unknown0, - ULONG Unknown1, - ULONG Unknown2, - ULONG Unknown3) -{ - -} - -/* - * @unimplemented - */ -BOOLEAN STDCALL CsrFreeCaptureBuffer (PVOID CaptureBuffer) -{ - /* FIXME: use NTDLL own heap */ - return RtlFreeHeap (hCaptureHeap, 0, CaptureBuffer); + /* Do the probe */ + Pointer = (PUCHAR)Address; + Data = *Pointer; + Pointer = (PUCHAR)((ULONG)Address + Length -1); + Data = *Pointer; } /* * @implemented */ -PLARGE_INTEGER STDCALL -CsrCaptureTimeout(LONG Milliseconds, - PLARGE_INTEGER Timeout) +VOID +NTAPI +CsrProbeForWrite(IN PVOID Address, + IN ULONG Length, + IN ULONG Alignment) { - if (Milliseconds == -1) - return NULL; + PUCHAR Pointer; + UCHAR Data; - Timeout->QuadPart = Milliseconds * -100000; - return Timeout; + /* Validate length */ + if (Length == 0) return; + + /* Validate alignment */ + if ((ULONG_PTR)Address & (Alignment - 1)) + { + /* Raise exception if it doesn't match */ + RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT); + } + + /* Do the probe */ + Pointer = (PUCHAR)Address; + Data = *Pointer; + *Pointer = Data; + Pointer = (PUCHAR)((ULONG)Address + Length -1); + Data = *Pointer; + *Pointer = Data; +} + +/* + * @implemented + */ +PVOID +NTAPI +CsrAllocateCaptureBuffer(ULONG ArgumentCount, + ULONG BufferSize) +{ + PCSR_CAPTURE_BUFFER CaptureBuffer; + + /* Validate size */ + if (BufferSize >= MAXLONG) return NULL; + + /* Add the size of the header and for each pointer to the pointers */ + BufferSize += sizeof(CSR_CAPTURE_BUFFER) + (ArgumentCount * sizeof(PVOID)); + + /* Allocate memory from the port heap */ + CaptureBuffer = RtlAllocateHeap(CsrPortHeap, 0, BufferSize); + + /* Initialize the header */ + CaptureBuffer->Size = BufferSize; + CaptureBuffer->PointerCount = 0; + + /* Initialize all the pointers */ + RtlZeroMemory(CaptureBuffer->PointerArray, + ArgumentCount * sizeof(ULONG_PTR)); + + /* Point the start of the free buffer */ + CaptureBuffer->BufferEnd = (ULONG_PTR)CaptureBuffer->PointerArray + + ArgumentCount * sizeof(ULONG_PTR); + + /* Return the address of the buffer */ + return CaptureBuffer; +} + +/* + * @implemented + */ +ULONG +NTAPI +CsrAllocateMessagePointer(PCSR_CAPTURE_BUFFER CaptureBuffer, + ULONG MessageLength, + PVOID *CaptureData) +{ + /* If there's no data, our job is easy. */ + if (MessageLength == 0) + { + *CaptureData = NULL; + CaptureData = NULL; + } + else + { + /* Set the capture data at our current available buffer */ + *CaptureData = (PVOID)CaptureBuffer->BufferEnd; + + /* Validate the size */ + if (MessageLength >= MAXLONG) return 0; + + /* Align it to a 4-byte boundary */ + MessageLength = (MessageLength + 3) & ~3; + + /* Move our available buffer beyond this space */ + CaptureBuffer->BufferEnd += MessageLength; + } + + /* Increase the pointer count */ + CaptureBuffer->PointerCount++; + + /* Write down this pointer in the array */ + CaptureBuffer->PointerArray[CaptureBuffer->PointerCount] = (ULONG_PTR)CaptureData; + + /* Return the aligned length */ + return MessageLength; +} + +/* + * @implemented + */ +VOID +NTAPI +CsrCaptureMessageBuffer(PCSR_CAPTURE_BUFFER CaptureBuffer, + PVOID MessageString, + ULONG StringLength, + PVOID *CapturedData) +{ + /* Simply allocate a message pointer in the buffer */ + CsrAllocateMessagePointer(CaptureBuffer, StringLength, CapturedData); + + /* Check if there was any data */ + if (!MessageString || !StringLength) return; + + /* Copy the data into the buffer */ + RtlMoveMemory(*CapturedData, MessageString, StringLength); +} + +/* + * @implemented + */ +VOID +NTAPI +CsrFreeCaptureBuffer(PCSR_CAPTURE_BUFFER CaptureBuffer) +{ + /* Free it from the heap */ + RtlFreeHeap(CsrPortHeap, 0, CaptureBuffer); +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrCaptureMessageMultiUnicodeStringsInPlace(IN PCSR_CAPTURE_BUFFER *CaptureBuffer, + IN ULONG MessageCount, + IN PVOID MessageStrings) +{ + /* FIXME: allocate a buffer if we don't have one, and return it */ + /* FIXME: call CsrCaptureMessageUnicodeStringInPlace for each string */ + UNIMPLEMENTED; + return STATUS_NOT_IMPLEMENTED; +} + +/* + * @implemented + */ +VOID +NTAPI +CsrCaptureMessageString(PCSR_CAPTURE_BUFFER CaptureBuffer, + LPSTR String, + IN ULONG StringLength, + IN ULONG MaximumLength, + OUT PANSI_STRING CapturedString) +{ + ULONG ReturnedLength; + + /* If we don't have a string, initialize an empty one */ + if (!String) + { + CapturedString->Length = 0; + CapturedString->MaximumLength = MaximumLength; + + /* Allocate a pointer for it */ + CsrAllocateMessagePointer(CaptureBuffer, + MaximumLength, + (PVOID*)&CapturedString->Buffer); + return; + } + + /* Initialize this string */ + CapturedString->Length = StringLength; + + /* Allocate a buffer and get its size */ + ReturnedLength = CsrAllocateMessagePointer(CaptureBuffer, + MaximumLength, + (PVOID*)&CapturedString->Buffer); + CapturedString->MaximumLength = ReturnedLength; + + /* If the string had data */ + if (StringLength) + { + /* Copy it into the capture buffer */ + RtlMoveMemory(CapturedString->Buffer, String, MaximumLength); + + /* If we don't take up the whole space */ + if (CapturedString->Length < CapturedString->MaximumLength) + { + /* Null-terminate it */ + CapturedString->Buffer[CapturedString->Length] = '\0'; + } + } +} + +/* + * @implemented + */ +PLARGE_INTEGER +NTAPI +CsrCaptureTimeout(LONG Milliseconds, + PLARGE_INTEGER Timeout) +{ + /* Validate the time */ + if (Milliseconds == -1) return NULL; + + /* Convert to relative ticks */ + Timeout->QuadPart = Milliseconds * -100000; + return Timeout; } /* EOF */ diff --git a/reactos/lib/ntdll/csr/connect.c b/reactos/lib/ntdll/csr/connect.c new file mode 100644 index 00000000000..26fee8ac65e --- /dev/null +++ b/reactos/lib/ntdll/csr/connect.c @@ -0,0 +1,430 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: lib/ntdll/csr/connect.c + * PURPOSE: Routines for connecting and calling CSR + * PROGRAMMER: Alex Ionescu (alex@relsoft.net) + */ + +/* INCLUDES *****************************************************************/ + +#include +#define NDEBUG +#include + +/* GLOBALS *******************************************************************/ + +HANDLE CsrApiPort; +HANDLE CsrProcessId; +HANDLE CsrPortHeap; +ULONG_PTR CsrPortMemoryDelta; +BOOLEAN InsideCsrProcess = FALSE; +BOOLEAN UsingOldCsr = TRUE; + +typedef NTSTATUS +(NTAPI *PCSR_SERVER_API_ROUTINE)(IN PPORT_MESSAGE Request, + IN PPORT_MESSAGE Reply); + +PCSR_SERVER_API_ROUTINE CsrServerApiRoutine; + +#define UNICODE_PATH_SEP L"\\" +#define CSR_PORT_NAME L"ApiPort" + +/* FUNCTIONS *****************************************************************/ + +/* + * @implemented + */ +HANDLE +NTAPI +CsrGetProcessId(VOID) +{ + return CsrProcessId; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrClientCallServer(PCSR_API_MESSAGE ApiMessage, + PCSR_CAPTURE_BUFFER CaptureBuffer OPTIONAL, + CSR_API_NUMBER ApiNumber, + ULONG RequestLength) +{ + NTSTATUS Status; + ULONG PointerCount; + PULONG_PTR Pointers; + ULONG_PTR CurrentPointer; + DPRINT("CsrClientCallServer\n"); + + /* Fill out the Port Message Header */ + ApiMessage->Header.u1.s1.DataLength = RequestLength - sizeof(PORT_MESSAGE); + ApiMessage->Header.u1.s1.TotalLength = RequestLength; + + /* Fill out the CSR Header */ + ApiMessage->Type = ApiNumber; + //ApiMessage->Opcode = ApiNumber; <- Activate with new CSR + ApiMessage->CsrCaptureData = NULL; + + DPRINT("API: %x, u1.s1.DataLength: %x, u1.s1.TotalLength: %x\n", + ApiNumber, + ApiMessage->Header.u1.s1.DataLength, + ApiMessage->Header.u1.s1.TotalLength); + + /* Check if we are already inside a CSR Server */ + if (!InsideCsrProcess) + { + /* Check if we got a a Capture Buffer */ + if (CaptureBuffer) + { + /* We have to convert from our local view to the remote view */ + DPRINT1("Converting CaptureBuffer\n"); + ApiMessage->CsrCaptureData = (PVOID)((ULONG_PTR)CaptureBuffer + + CsrPortMemoryDelta); + + /* Lock the buffer */ + CaptureBuffer->BufferEnd = 0; + + /* Get the pointer information */ + PointerCount = CaptureBuffer->PointerCount; + Pointers = CaptureBuffer->PointerArray; + + /* Loop through every pointer and convert it */ + while (PointerCount--) + { + /* Get this pointer and check if it's valid */ + if ((CurrentPointer = *Pointers++)) + { + /* Update it */ + *(PULONG_PTR)CurrentPointer += CsrPortMemoryDelta; + Pointers[-1] = CurrentPointer - (ULONG_PTR)ApiMessage; + } + } + } + + /* Send the LPC Message */ + Status = NtRequestWaitReplyPort(CsrApiPort, + &ApiMessage->Header, + &ApiMessage->Header); + + /* Check if we got a a Capture Buffer */ + if (CaptureBuffer) + { + /* We have to convert from the remote view to our remote view */ + DPRINT1("Reconverting CaptureBuffer\n"); + ApiMessage->CsrCaptureData = (PVOID)((ULONG_PTR) + ApiMessage->CsrCaptureData - + CsrPortMemoryDelta); + + /* Get the pointer information */ + PointerCount = CaptureBuffer->PointerCount; + Pointers = CaptureBuffer->PointerArray; + + /* Loop through every pointer and convert it */ + while (PointerCount--) + { + /* Get this pointer and check if it's valid */ + if ((CurrentPointer = *Pointers++)) + { + /* Update it */ + CurrentPointer += (ULONG_PTR)ApiMessage; + Pointers[-1] = CurrentPointer; + *(PULONG_PTR)CurrentPointer -= CsrPortMemoryDelta; + } + } + } + + /* Check for success */ + if (!NT_SUCCESS(Status)) + { + /* We failed. Overwrite the return value with the failure */ + DPRINT1("LPC Failed: %lx\n", Status); + ApiMessage->Status = Status; + } + } + else + { + /* This is a server-to-server call. Save our CID and do a direct call */ + DbgBreakPoint(); + ApiMessage->Header.ClientId = NtCurrentTeb()->Cid; + Status = CsrServerApiRoutine(&ApiMessage->Header, + &ApiMessage->Header); + + /* Check for success */ + if (!NT_SUCCESS(Status)) + { + /* We failed. Overwrite the return value with the failure */ + ApiMessage->Status = Status; + } + } + + /* Return the CSR Result */ + DPRINT("Got back: %x\n", ApiMessage->Status); + return ApiMessage->Status; +} + +NTSTATUS +NTAPI +CsrConnectToServer(IN PWSTR ObjectDirectory) +{ + ULONG PortNameLength; + UNICODE_STRING PortName; + LARGE_INTEGER CsrSectionViewSize; + NTSTATUS Status; + HANDLE CsrSectionHandle; + PORT_VIEW LpcWrite; + REMOTE_PORT_VIEW LpcRead; + SECURITY_QUALITY_OF_SERVICE SecurityQos; + SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY}; + PSID SystemSid = NULL; + CSR_CONNECTION_INFO ConnectionInfo; + ULONG ConnectionInfoLength = sizeof(CSR_CONNECTION_INFO); + DPRINT("CsrConnectToServer\n"); + + /* Calculate the total port name size */ + PortNameLength = ((wcslen(ObjectDirectory) + 1) * sizeof(WCHAR)) + + sizeof(CSR_PORT_NAME); + + /* Set the port name */ + PortName.Length = 0; + PortName.MaximumLength = PortNameLength; + + /* Allocate a buffer for it */ + PortName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, PortNameLength); + + /* Create the name */ + RtlAppendUnicodeToString(&PortName, ObjectDirectory ); + RtlAppendUnicodeToString(&PortName, UNICODE_PATH_SEP); + RtlAppendUnicodeToString(&PortName, CSR_PORT_NAME); + + /* Create a section for the port memory */ + CsrSectionViewSize.QuadPart = CSR_CSRSS_SECTION_SIZE; + Status = NtCreateSection(&CsrSectionHandle, + SECTION_ALL_ACCESS, + NULL, + &CsrSectionViewSize, + PAGE_READWRITE, + SEC_COMMIT, + NULL); + if (!NT_SUCCESS(Status)) + { + DPRINT1("Failure allocating CSR Section\n"); + return Status; + } + + /* Set up the port view structures to match them with the section */ + LpcWrite.Length = sizeof(PORT_VIEW); + LpcWrite.SectionHandle = CsrSectionHandle; + LpcWrite.SectionOffset = 0; + LpcWrite.ViewSize = CsrSectionViewSize.u.LowPart; + LpcWrite.ViewBase = 0; + LpcWrite.ViewRemoteBase = 0; + LpcRead.Length = sizeof(REMOTE_PORT_VIEW); + LpcRead.ViewSize = 0; + LpcRead.ViewBase = 0; + + /* Setup the QoS */ + SecurityQos.ImpersonationLevel = SecurityImpersonation; + SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; + SecurityQos.EffectiveOnly = TRUE; + + /* Setup the connection info */ + ConnectionInfo.Version = 0x10000; + + /* Create a SID for us */ + Status = RtlAllocateAndInitializeSid(&NtSidAuthority, + 1, + SECURITY_LOCAL_SYSTEM_RID, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + &SystemSid); + + /* Connect to the port */ + Status = NtSecureConnectPort(&CsrApiPort, + &PortName, + &SecurityQos, + &LpcWrite, + SystemSid, + &LpcRead, + NULL, + &ConnectionInfo, + &ConnectionInfoLength); + NtClose(CsrSectionHandle); + if (!NT_SUCCESS(Status)) + { + /* Failure */ + DPRINT1("Couldn't connect to CSR port\n"); + return Status; + } + + /* Save the delta between the sections, for capture usage later */ + CsrPortMemoryDelta = (ULONG_PTR)LpcWrite.ViewRemoteBase - + (ULONG_PTR)LpcWrite.ViewBase; + + /* Save the Process */ + CsrProcessId = ConnectionInfo.ProcessId; + + /* Save CSR Section data */ + NtCurrentPeb()->ReadOnlySharedMemoryBase = ConnectionInfo.SharedSectionBase; + NtCurrentPeb()->ReadOnlySharedMemoryHeap = ConnectionInfo.SharedSectionHeap; + NtCurrentPeb()->ReadOnlyStaticServerData = ConnectionInfo.SharedSectionData; + + /* Create the port heap */ + CsrPortHeap = RtlCreateHeap(0, + LpcWrite.ViewBase, + LpcWrite.ViewSize, + PAGE_SIZE, + 0, + 0); + + /* Return success */ + return STATUS_SUCCESS; +} + +/* + * @implemented + */ +NTSTATUS +NTAPI +CsrClientConnectToServer(PWSTR ObjectDirectory, + ULONG ServerId, + PVOID ConnectionInfo, + PULONG ConnectionInfoSize, + PBOOLEAN ServerToServerCall) +{ + NTSTATUS Status; + PIMAGE_NT_HEADERS NtHeader; + UNICODE_STRING CsrSrvName; + HANDLE hCsrSrv; + ANSI_STRING CsrServerRoutineName; + PCSR_CAPTURE_BUFFER CaptureBuffer; + CSR_API_MESSAGE RosApiMessage; + CSR_API_MESSAGE2 ApiMessage; + PCSR_CLIENT_CONNECT ClientConnect = &ApiMessage.ClientConnect; + + /* Validate the Connection Info */ + DPRINT("CsrClientConnectToServer: %lx %p\n", ServerId, ConnectionInfo); + if (ConnectionInfo && (!ConnectionInfoSize || !*ConnectionInfoSize)) + { + DPRINT1("Connection info given, but no length\n"); + return STATUS_INVALID_PARAMETER; + } + + /* Check if we're inside a CSR Process */ + if (InsideCsrProcess) + { + /* Tell the client that we're already inside CSR */ + if (ServerToServerCall) *ServerToServerCall = TRUE; + return STATUS_SUCCESS; + } + + /* + * We might be in a CSR Process but not know it, if this is the first call. + * So let's find out. + */ + if (!(NtHeader = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress))) + { + /* The image isn't valid */ + DPRINT1("Invalid image\n"); + return STATUS_INVALID_IMAGE_FORMAT; + } + InsideCsrProcess = (NtHeader->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_NATIVE); + + /* Now we can check if we are inside or not */ + if (InsideCsrProcess && !UsingOldCsr) + { + /* We're inside, so let's find csrsrv */ + DbgBreakPoint(); + RtlInitUnicodeString(&CsrSrvName, L"csrsrv"); + Status = LdrGetDllHandle(NULL, + NULL, + &CsrSrvName, + &hCsrSrv); + RtlFreeUnicodeString(&CsrSrvName); + + /* Now get the Server to Server routine */ + RtlInitAnsiString(&CsrServerRoutineName, "CsrCallServerFromServer"); + Status = LdrGetProcedureAddress(hCsrSrv, + &CsrServerRoutineName, + 0L, + (PVOID*)&CsrServerApiRoutine); + + /* Use the local heap as port heap */ + CsrPortHeap = RtlGetProcessHeap(); + + /* Tell the caller we're inside the server */ + *ServerToServerCall = InsideCsrProcess; + return STATUS_SUCCESS; + } + + /* Now check if connection info is given */ + if (ConnectionInfo) + { + /* Well, we're defintely in a client now */ + InsideCsrProcess = FALSE; + + /* Do we have a connection to CSR yet? */ + if (!CsrApiPort) + { + /* No, set it up now */ + if (!NT_SUCCESS(Status = CsrConnectToServer(ObjectDirectory))) + { + /* Failed */ + DPRINT1("Failure to connect to CSR\n"); + return Status; + } + } + + /* Setup the connect message header */ + ClientConnect->ServerId = ServerId; + ClientConnect->ConnectionInfoSize = *ConnectionInfoSize; + + /* Setup a buffer for the connection info */ + CaptureBuffer = CsrAllocateCaptureBuffer(1, + ClientConnect->ConnectionInfoSize); + + /* Allocate a pointer for the connection info*/ + CsrAllocateMessagePointer(CaptureBuffer, + ClientConnect->ConnectionInfoSize, + &ClientConnect->ConnectionInfo); + + /* Copy the data into the buffer */ + RtlMoveMemory(ClientConnect->ConnectionInfo, + ConnectionInfo, + ClientConnect->ConnectionInfoSize); + + /* Return the allocated length */ + *ConnectionInfoSize = ClientConnect->ConnectionInfoSize; + + /* Call CSR */ +#if 0 + Status = CsrClientCallServer(&ApiMessage, + CaptureBuffer, + CSR_MAKE_OPCODE(CsrSrvClientConnect, + CSR_SRV_DLL), + sizeof(CSR_CLIENT_CONNECT)); +#endif + Status = CsrClientCallServer(&RosApiMessage, + NULL, + MAKE_CSR_API(CONNECT_PROCESS, CSR_NATIVE), + sizeof(CSR_API_MESSAGE)); + } + else + { + /* No connection info, just return */ + Status = STATUS_SUCCESS; + } + + /* Let the caller know if this was server to server */ + DPRINT("Status was: %lx. Are we in server: %lx\n", Status, InsideCsrProcess); + if (ServerToServerCall) *ServerToServerCall = InsideCsrProcess; + return Status; +} + +/* EOF */ diff --git a/reactos/lib/ntdll/csr/lpc.c b/reactos/lib/ntdll/csr/lpc.c deleted file mode 100644 index 8dd1b4bc3bb..00000000000 --- a/reactos/lib/ntdll/csr/lpc.c +++ /dev/null @@ -1,194 +0,0 @@ -/* $Id$ - * - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: lib/ntdll/csr/lpc.c - * PURPOSE: CSRSS Client/Server LPC API - * - * REVISIONS: - * 2001-06-16 (ea) - * File api.c renamed lpc.c. Process/thread code moved - * in thread.c. Check added on the LPC port. - */ - -/* INCLUDES *****************************************************************/ - -#include -#define NDEBUG -#include - -/* GLOBALS *******************************************************************/ - -HANDLE WindowsApiPort = INVALID_HANDLE_VALUE; -static PVOID CsrSectionMapBase = NULL; -static PVOID CsrSectionMapServerBase = NULL; -static HANDLE CsrCommHeap = NULL; - -#define CSR_CONTROL_HEAP_SIZE (65536) - -/* FUNCTIONS *****************************************************************/ - -/* Possible CsrClientCallServer (the NT one): */ - -NTSTATUS STDCALL -CsrCaptureParameterBuffer(PVOID ParameterBuffer, - ULONG ParameterBufferSize, - PVOID* ClientAddress, - PVOID* ServerAddress) -{ - PVOID Block; - - Block = RtlAllocateHeap(CsrCommHeap, 0, ParameterBufferSize); - if (Block == NULL) - { - return(STATUS_NO_MEMORY); - } - if(ParameterBuffer != NULL) - { - memcpy(Block, ParameterBuffer, ParameterBufferSize); - } - *ClientAddress = Block; - *ServerAddress = (PVOID)((ULONG_PTR)Block - (ULONG_PTR)CsrSectionMapBase + (ULONG_PTR)CsrSectionMapServerBase); - return(STATUS_SUCCESS); -} - -NTSTATUS STDCALL -CsrReleaseParameterBuffer(PVOID ClientAddress) -{ - RtlFreeHeap(CsrCommHeap, 0, ClientAddress); - return(STATUS_SUCCESS); -} - -/* - * @implemented - */ -NTSTATUS -STDCALL -CsrClientCallServer(PCSR_API_MESSAGE Request, - PVOID CapturedBuffer OPTIONAL, - CSR_API_NUMBER ApiNumber, - ULONG RequestLength) -{ - NTSTATUS Status; - DPRINT("CSR: CsrClientCallServer!\n"); - - /* Make sure it's valid */ - if (INVALID_HANDLE_VALUE == WindowsApiPort) - { - DPRINT1("NTDLL.%s: client not connected to CSRSS!\n", __FUNCTION__); - return (STATUS_UNSUCCESSFUL); - } - - /* Fill out the header */ - Request->Type = ApiNumber; - Request->Header.u1.s1.DataLength = RequestLength - sizeof(PORT_MESSAGE); - Request->Header.u1.s1.TotalLength = RequestLength; - DPRINT("CSR: API: %x, u1.s1.DataLength: %x, u1.s1.TotalLength: %x\n", - ApiNumber, - Request->Header.u1.s1.DataLength, - Request->Header.u1.s1.TotalLength); - - /* Send the LPC Message */ - Status = NtRequestWaitReplyPort(WindowsApiPort, - &Request->Header, - &Request->Header); - - DPRINT("Got back: %x\n", Status); - return(Status); -} - -/* - * @implemented - */ -NTSTATUS -STDCALL -CsrClientConnectToServer(PWSTR ObjectDirectory, - ULONG ServerId, - PVOID Unknown, - PVOID Context, - ULONG ContextLength, - PBOOLEAN ServerToServerCall) -{ - NTSTATUS Status = STATUS_SUCCESS; - UNICODE_STRING PortName; - ULONG ConnectInfoLength; - CSR_API_MESSAGE Request; - PORT_VIEW LpcWrite; - HANDLE CsrSectionHandle; - LARGE_INTEGER CsrSectionViewSize; - - if (WindowsApiPort != INVALID_HANDLE_VALUE) - { - return STATUS_SUCCESS; - } - - if (NULL == ObjectDirectory) - { - return STATUS_INVALID_PARAMETER; - } - - RtlInitUnicodeString (& PortName, ObjectDirectory); - - CsrSectionViewSize.QuadPart = CSR_CSRSS_SECTION_SIZE; - Status = NtCreateSection(&CsrSectionHandle, - SECTION_ALL_ACCESS, - NULL, - &CsrSectionViewSize, - PAGE_READWRITE, - SEC_COMMIT, - NULL); - if (!NT_SUCCESS(Status)) - { - return(Status); - } - ConnectInfoLength = 0; - LpcWrite.Length = sizeof(PORT_VIEW); - LpcWrite.SectionHandle = CsrSectionHandle; - LpcWrite.SectionOffset = 0; - LpcWrite.ViewSize = CsrSectionViewSize.u.LowPart; - Status = NtConnectPort(&WindowsApiPort, - &PortName, - NULL, - &LpcWrite, - NULL, - NULL, - NULL, - &ConnectInfoLength); - if (!NT_SUCCESS(Status)) - { - WindowsApiPort = INVALID_HANDLE_VALUE; - return(Status); - } - - NtClose(CsrSectionHandle); - CsrSectionMapBase = LpcWrite.ViewBase; - CsrSectionMapServerBase = LpcWrite.ViewRemoteBase; - - /* Create the heap for communication for csrss. */ - CsrCommHeap = RtlCreateHeap(0, - CsrSectionMapBase, - CsrSectionViewSize.u.LowPart, - CsrSectionViewSize.u.LowPart, - 0, - NULL); - if (CsrCommHeap == NULL) - { - return(STATUS_NO_MEMORY); - } - - Status = CsrClientCallServer(&Request, - NULL, - MAKE_CSR_API(CONNECT_PROCESS, CSR_NATIVE), - sizeof(CSR_API_MESSAGE)); - if (!NT_SUCCESS(Status)) - { - return(Status); - } - if (!NT_SUCCESS(Request.Status)) - { - return(Request.Status); - } - return(STATUS_SUCCESS); -} - -/* EOF */ diff --git a/reactos/lib/ntdll/csr/probe.c b/reactos/lib/ntdll/csr/probe.c deleted file mode 100644 index 50208122305..00000000000 --- a/reactos/lib/ntdll/csr/probe.c +++ /dev/null @@ -1,66 +0,0 @@ -/* $Id$ - * - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: lib/ntdll/csr/probe.c - * PURPOSE: CSRSS address range access probing API - * AUTHOR: Eric Kohl - * DATE: 2001-06-17 - */ - -#include -#define NDEBUG -#include - -/* - * @implemented - */ -VOID STDCALL -CsrProbeForRead(IN CONST PVOID Address, - IN ULONG Length, - IN ULONG Alignment) -{ - PUCHAR Pointer; - UCHAR Data; - - if (Length == 0) - return; - - if ((ULONG)Address & (Alignment - 1)) - RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT); - - Pointer = (PUCHAR)Address; - Data = *Pointer; - Pointer = (PUCHAR)((ULONG)Address + Length -1); - Data = *Pointer; -} - -/* - * @implemented - */ -VOID STDCALL -CsrProbeForWrite(IN CONST PVOID Address, - IN ULONG Length, - IN ULONG Alignment) -{ - PUCHAR Pointer; - UCHAR Data; - - if (Length == 0) - return; - - if ((ULONG)Address & (Alignment - 1)) - RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT); - -// if (Address >= MmUserProbeAddress) -// RtlRaiseStatus(STATUS_ACCESS_VIOLATION); - - Pointer = (PUCHAR)Address; - Data = *Pointer; - *Pointer = Data; - Pointer = (PUCHAR)((ULONG)Address + Length -1); - Data = *Pointer; - *Pointer = Data; -} - -/* EOF */ diff --git a/reactos/lib/ntdll/csr/srv.c b/reactos/lib/ntdll/csr/srv.c deleted file mode 100644 index 21b4c8a15e6..00000000000 --- a/reactos/lib/ntdll/csr/srv.c +++ /dev/null @@ -1,25 +0,0 @@ -/* $Id$ - * - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: lib/ntdll/csr/srv.c - * PURPOSE: Get CSR.EXE PID - * - */ - -/* INCLUDES *****************************************************************/ - -#include -#define NDEBUG -#include - -/* GLOBALS *******************************************************************/ - -DWORD ProcessId = 0; // TODO: set it on startup - -DWORD STDCALL CsrGetProcessId (VOID) -{ - return ProcessId; -} - -/* EOF */ diff --git a/reactos/lib/ntdll/csr/thread.c b/reactos/lib/ntdll/csr/thread.c deleted file mode 100644 index 71951d9074a..00000000000 --- a/reactos/lib/ntdll/csr/thread.c +++ /dev/null @@ -1,60 +0,0 @@ -/* $Id$ - * - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * FILE: lib/ntdll/csr/propvar.c - * PURPOSE: CSRSS threads API - */ - -#include -#define NDEBUG -#include - -/* - * @implemented - */ -NTSTATUS STDCALL -CsrNewThread(VOID) -{ - return (NtRegisterThreadTerminatePort(WindowsApiPort)); -} - -/* - * @unimplemented - */ -NTSTATUS STDCALL -CsrSetPriorityClass(HANDLE Process, - PULONG PriorityClass) -{ - /* FIXME: call csrss to get hProcess' priority */ - *PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; - - return (STATUS_NOT_IMPLEMENTED); -} - -/* - * @unimplemented - */ -NTSTATUS -STDCALL -CsrIdentifyAlertableThread (VOID) -{ - /* FIXME: notify csrss that current thread is alertable */ -#if 0 - CSRSS_IDENTIFY_ALERTABLE_THREAD_REPLY Reply; - CSRSS_IDENTIFY_ALERTABLE_THREAD_REQUEST Request = (PCSRSS_IDENTIFY_ALERTABLE_THREAD_REQUEST) & Reply; - PNT_TEB Teb; - - Request->UniqueThread = NtCurrentTeb()->Cid.UniqueThread; - /* FIXME: this is written the NT way, NOT the ROS way! */ - return CsrClientCallServer ( - Request, - NULL, /* use Request storage for reply */ - CSRSS_IDENTIFY_ALERTABLE_THREAD, - sizeof (CSRSS_IDENTIFY_ALERTABLE_THREAD_REPLY) - ); -#endif - return (STATUS_NOT_IMPLEMENTED); -} - -/* EOF */ diff --git a/reactos/lib/ntdll/def/ntdll.def b/reactos/lib/ntdll/def/ntdll.def index ad84e2e758b..6674365ad7d 100644 --- a/reactos/lib/ntdll/def/ntdll.def +++ b/reactos/lib/ntdll/def/ntdll.def @@ -5,16 +5,14 @@ LIBRARY ntdll.dll EXPORTS -CsrCaptureParameterBuffer@16 -CsrReleaseParameterBuffer@4 -CsrAllocateCaptureBuffer@12 -CsrAllocateCapturePointer@12 +CsrAllocateCaptureBuffer@8 CsrAllocateMessagePointer@12 CsrCaptureMessageBuffer@16 +CsrCaptureMessageMultiUnicodeStringsInPlace@12 CsrCaptureMessageString@20 CsrCaptureTimeout@8 CsrClientCallServer@16 -CsrClientConnectToServer@24 +CsrClientConnectToServer@20 CsrFreeCaptureBuffer@4 CsrGetProcessId@0 CsrIdentifyAlertableThread@0 @@ -219,6 +217,7 @@ NtRestoreKey@12 NtResumeProcess@4 NtResumeThread@8 NtSaveKey@8 +NtSecureConnectPort@36 NtSetContextThread@8 NtSetDefaultHardErrorPort@4 NtSetDefaultLocale@8 @@ -852,6 +851,7 @@ ZwRestoreKey@12 ZwResumeProcess@4 ZwResumeThread@8 ZwSaveKey@8 +ZwSecureConnectPort@36 ZwSetContextThread@8 ZwSetDefaultHardErrorPort@4 ZwSetDefaultLocale@8 diff --git a/reactos/lib/ntdll/ntdll.xml b/reactos/lib/ntdll/ntdll.xml index bb2dc919bb3..7a954ff3bcc 100644 --- a/reactos/lib/ntdll/ntdll.xml +++ b/reactos/lib/ntdll/ntdll.xml @@ -14,11 +14,9 @@ -lgcc -nostartfiles + api.c capture.c - lpc.c - probe.c - srv.c - thread.c + connect.c debug.c diff --git a/reactos/subsys/csrss/init.c b/reactos/subsys/csrss/init.c index fa4bb758e21..fede65d6a3b 100644 --- a/reactos/subsys/csrss/init.c +++ b/reactos/subsys/csrss/init.c @@ -458,8 +458,10 @@ CsrpApiRegisterDef (ULONG argc, PWSTR* argv) static NTSTATUS CsrpCCTS (ULONG argc, PWSTR* argv) { - return CsrClientConnectToServer(L"\\Windows\\ApiPort", - 0, NULL, NULL, 0, NULL); + ULONG Dummy; + ULONG DummyLength = sizeof(Dummy); + return CsrClientConnectToServer(L"\\Windows", + 0, &Dummy, &DummyLength, NULL); } /********************************************************************** diff --git a/reactos/tools/nci/sysfuncs.lst b/reactos/tools/nci/sysfuncs.lst index ab956599dee..3f2b5925157 100644 --- a/reactos/tools/nci/sysfuncs.lst +++ b/reactos/tools/nci/sysfuncs.lst @@ -170,6 +170,7 @@ NtResumeProcess 1 NtResumeThread 2 NtSaveKey 2 NtSaveKeyEx 3 +NtSecureConnectPort 9 NtSetBootEntryOrder 2 NtSetBootOptions 2 NtSetIoCompletion 5