/* Internal CSRSS Headers */
#include <api.h>
-#include <conio.h>
#include <csrplugin.h>
CsrProcessIsConsoleApp = 0x800
} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS;
-typedef struct Object_tt
-{
- LONG Type;
- LONG ReferenceCount;
- CRITICAL_SECTION Lock;
-} Object_t;
-
-typedef struct ConsoleInput_t
-{
- LIST_ENTRY ListEntry;
- INPUT_RECORD InputEvent;
- BOOLEAN Echoed; // already been echoed or not
- BOOLEAN Fake; // synthesized, not a real event
- BOOLEAN NotChar; // message should not be used to return a character
-} ConsoleInput;
-
-typedef struct tagCSRSS_CONSOLE *PCSRSS_CONSOLE;
-
-typedef struct _CSRSS_HANDLE
-{
- Object_t *Object;
- DWORD Access;
- BOOL Inheritable;
-} CSRSS_HANDLE, *PCSRSS_HANDLE;
-
typedef struct _CSRSS_PROCESS_DATA
{
struct tagCSRSS_CONSOLE *Console;
BOOL bInheritHandles;
RTL_CRITICAL_SECTION HandleTableLock;
ULONG HandleTableSize;
- PCSRSS_HANDLE HandleTable;
+ struct _CSRSS_HANDLE *HandleTable;
HANDLE ProcessId;
DWORD ProcessGroup;
HANDLE Process;
ULONG ImpersonationCount;
} CSR_THREAD, *PCSR_THREAD;
-typedef VOID (WINAPI *CSR_CLEANUP_OBJECT_PROC)(Object_t *Object);
-
-typedef struct tagCSRSS_OBJECT_DEFINITION
-{
- LONG Type;
- CSR_CLEANUP_OBJECT_PROC CsrCleanupObjectProc;
-} CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION;
-
typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request);
/* init.c */
extern HANDLE hBootstrapOk;
+NTSTATUS NTAPI CsrServerInitialization(ULONG ArgumentCount, PCHAR Arguments[]);
/* api/process.c */
CSR_API(CsrConnectProcess);
CSR_API(CsrCreateProcess);
CSR_API(CsrTerminateProcess);
CSR_API(CsrSrvCreateThread);
-
-/* print.c */
-VOID WINAPI DisplayString(LPCWSTR lpwString);
-VOID WINAPI PrintString (char* fmt, ...);
+CSR_API(CsrGetShutdownParameters);
+CSR_API(CsrSetShutdownParameters);
/* api/wapi.c */
NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request);
-DWORD WINAPI ServerApiPortThread (PVOID PortHandle);
DWORD WINAPI ServerSbApiPortThread (PVOID PortHandle);
-DWORD WINAPI Console_Api( PVOID unused );
-VOID
-NTAPI
-ClientConnectionThread(HANDLE ServerPort);
+VOID NTAPI ClientConnectionThread(HANDLE ServerPort);
extern HANDLE CsrssApiHeap;
-/* api/conio.c */
-VOID WINAPI CsrInitConsoleSupport(VOID);
-
/* api/process.c */
typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PVOID Context);
NTSTATUS NTAPI CsrCreateThread(IN PCSRSS_PROCESS_DATA CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId);
NTSTATUS NTAPI CsrUnlockProcess(IN PCSRSS_PROCESS_DATA CsrProcess);
-/* api/handle.c */
-NTSTATUS FASTCALL CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions);
-NTSTATUS WINAPI CsrInsertObject( PCSRSS_PROCESS_DATA ProcessData, PHANDLE Handle, Object_t *Object, DWORD Access, BOOL Inheritable );
-NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData, PCSRSS_PROCESS_DATA TargetProcessData);
-NTSTATUS WINAPI CsrGetObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle, Object_t **Object, DWORD Access );
-NTSTATUS NTAPI CsrServerInitialization(ULONG ArgumentCount, PCHAR Arguments[]);
-NTSTATUS WINAPI CsrReleaseObjectByPointer(Object_t *Object);
-NTSTATUS WINAPI CsrReleaseObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
-NTSTATUS WINAPI CsrReleaseConsole(PCSRSS_PROCESS_DATA ProcessData);
-NTSTATUS WINAPI CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Object );
-
//hack
VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread);
-CSR_API(CsrGetInputHandle);
-CSR_API(CsrGetOutputHandle);
-CSR_API(CsrCloseHandle);
-CSR_API(CsrVerifyHandle);
-CSR_API(CsrDuplicateHandle);
-CSR_API(CsrGetInputWaitHandle);
-
/* api/user.c */
CSR_API(CsrRegisterServicesProcess);
-CSR_API(CsrExitReactos);
-CSR_API(CsrGetShutdownParameters);
-CSR_API(CsrSetShutdownParameters);
-
-CSR_API(CsrSetLogonNotifyWindow);
-CSR_API(CsrRegisterLogonProcess);
/* EOF */
USHORT Mode;
} CSRSS_SCREEN_BUFFER, *PCSRSS_SCREEN_BUFFER;
+typedef struct tagCSRSS_CONSOLE *PCSRSS_CONSOLE;
+
typedef struct tagCSRSS_CONSOLE_VTBL
{
VOID (WINAPI *InitScreenBuffer)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
struct tagALIAS_HEADER *Aliases;
} CSRSS_CONSOLE;
+typedef struct ConsoleInput_t
+{
+ LIST_ENTRY ListEntry;
+ INPUT_RECORD InputEvent;
+ BOOLEAN Echoed; // already been echoed or not
+ BOOLEAN Fake; // synthesized, not a real event
+ BOOLEAN NotChar; // message should not be used to return a character
+} ConsoleInput;
+
NTSTATUS FASTCALL ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console);
VOID WINAPI ConioDeleteConsole(Object_t *Object);
VOID WINAPI ConioDeleteScreenBuffer(Object_t *Buffer);
+VOID WINAPI CsrInitConsoleSupport(VOID);
void WINAPI ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode);
PBYTE FASTCALL ConioCoordToPointer(PCSRSS_SCREEN_BUFFER Buf, ULONG X, ULONG Y);
VOID FASTCALL ConioDrawConsole(PCSRSS_CONSOLE Console);
{ 0, 0, NULL }
};
-static CSRSS_OBJECT_DEFINITION Win32CsrObjectDefinitions[] =
- {
- { CONIO_CONSOLE_MAGIC, ConioDeleteConsole },
- { CONIO_SCREEN_BUFFER_MAGIC, ConioDeleteScreenBuffer },
- { 0, NULL }
- };
-
/* FUNCTIONS *****************************************************************/
BOOL WINAPI
return TRUE;
}
-NTSTATUS FASTCALL
-Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
- PHANDLE Handle,
- Object_t *Object,
- DWORD Access,
- BOOL Inheritable)
-{
- return CsrInsertObject(ProcessData, Handle, Object, Access, Inheritable);
-}
-
-NTSTATUS FASTCALL
-Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
- HANDLE Handle,
- Object_t **Object,
- DWORD Access)
-{
- return CsrGetObject(ProcessData, Handle, Object, Access);
-}
-
-NTSTATUS FASTCALL
-Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData,
- HANDLE Handle,
- Object_t **Object,
- DWORD Access,
- LONG Type)
-{
- NTSTATUS Status;
-
- Status = CsrGetObject(ProcessData, Handle, Object, Access);
- if (! NT_SUCCESS(Status))
- {
- return Status;
- }
-
- if ((*Object)->Type != Type)
- {
- CsrReleaseObjectByPointer(*Object);
- return STATUS_INVALID_HANDLE;
- }
-
- EnterCriticalSection(&((*Object)->Lock));
-
- return STATUS_SUCCESS;
-}
-
-VOID FASTCALL
-Win32CsrUnlockObject(Object_t *Object)
-{
- LeaveCriticalSection(&(Object->Lock));
- CsrReleaseObjectByPointer(Object);
-}
-
-NTSTATUS FASTCALL
-Win32CsrReleaseObjectByPointer(Object_t *Object)
-{
- return CsrReleaseObjectByPointer(Object);
-}
-
-NTSTATUS FASTCALL
-Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
- HANDLE Object)
-{
- return CsrReleaseObject(ProcessData, Object);
-}
-
-NTSTATUS FASTCALL
-Win32CsrReleaseConsole(PCSRSS_PROCESS_DATA ProcessData)
-{
- return CsrReleaseConsole(ProcessData);
-}
-
NTSTATUS FASTCALL
Win32CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc,
PVOID Context)
PrivateCsrssManualGuiCheck(0);
CsrInitConsoleSupport();
- CsrRegisterObjectDefinitions(Win32CsrObjectDefinitions);
*ApiDefinitions = Win32CsrApiDefinitions;
ServerProcs->InitCompleteProc = Win32CsrInitComplete;
ServerProcs->HardErrorProc = Win32CsrHardError;
- ServerProcs->ProcessInheritProc = CsrDuplicateHandleTable;
- ServerProcs->ProcessDeletedProc = CsrReleaseConsole;
+ ServerProcs->ProcessInheritProc = Win32CsrDuplicateHandleTable;
+ ServerProcs->ProcessDeletedProc = Win32CsrReleaseConsole;
return TRUE;
}
/* FUNCTIONS *****************************************************************/
-static unsigned ObjectDefinitionsCount = 0;
-static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL;
+static unsigned ObjectDefinitionsCount = 2;
+static CSRSS_OBJECT_DEFINITION ObjectDefinitions[] =
+{
+ { CONIO_CONSOLE_MAGIC, ConioDeleteConsole },
+ { CONIO_SCREEN_BUFFER_MAGIC, ConioDeleteScreenBuffer },
+};
static
BOOL
return ((ULONG_PTR)Handle & 0x10000003) == 0x3;
}
-
NTSTATUS
FASTCALL
-CsrRegisterObjectDefinitions(
- PCSRSS_OBJECT_DEFINITION NewDefinitions)
-{
- unsigned NewCount;
- PCSRSS_OBJECT_DEFINITION Scan;
- PCSRSS_OBJECT_DEFINITION New;
-
- NewCount = 0;
- for (Scan = NewDefinitions; 0 != Scan->Type; Scan++)
- {
- NewCount++;
- }
-
- New = RtlAllocateHeap(Win32CsrApiHeap,
- 0,
- (ObjectDefinitionsCount + NewCount)
- * sizeof(CSRSS_OBJECT_DEFINITION));
- if (NULL == New)
- {
- DPRINT1("Unable to allocate memory\n");
- return STATUS_NO_MEMORY;
- }
-
- if (0 != ObjectDefinitionsCount)
- {
- RtlCopyMemory(New,
- ObjectDefinitions,
- ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
- RtlFreeHeap(Win32CsrApiHeap, 0, ObjectDefinitions);
- }
-
- RtlCopyMemory(New + ObjectDefinitionsCount,
- NewDefinitions,
- NewCount * sizeof(CSRSS_OBJECT_DEFINITION));
- ObjectDefinitions = New;
- ObjectDefinitionsCount += NewCount;
-
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-WINAPI
-CsrGetObject(
+Win32CsrGetObject(
PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object,
NTSTATUS
-WINAPI
-CsrReleaseObjectByPointer(
+FASTCALL
+Win32CsrReleaseObjectByPointer(
Object_t *Object)
{
unsigned DefIndex;
return STATUS_SUCCESS;
}
-
NTSTATUS
-WINAPI
-CsrReleaseObject(
+FASTCALL
+Win32CsrReleaseObject(
PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
{
ProcessData->HandleTable[h].Object = NULL;
RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return CsrReleaseObjectByPointer(Object);
+ return Win32CsrReleaseObjectByPointer(Object);
+}
+
+NTSTATUS
+FASTCALL
+Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData,
+ HANDLE Handle,
+ Object_t **Object,
+ DWORD Access,
+ LONG Type)
+{
+ NTSTATUS Status;
+
+ Status = Win32CsrGetObject(ProcessData, Handle, Object, Access);
+ if (! NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ if ((*Object)->Type != Type)
+ {
+ Win32CsrReleaseObjectByPointer(*Object);
+ return STATUS_INVALID_HANDLE;
+ }
+
+ EnterCriticalSection(&((*Object)->Lock));
+
+ return STATUS_SUCCESS;
+}
+
+VOID
+FASTCALL
+Win32CsrUnlockObject(Object_t *Object)
+{
+ LeaveCriticalSection(&(Object->Lock));
+ Win32CsrReleaseObjectByPointer(Object);
}
NTSTATUS
WINAPI
-CsrReleaseConsole(
+Win32CsrReleaseConsole(
PCSRSS_PROCESS_DATA ProcessData)
{
ULONG HandleTableSize;
for (i = 0; i < HandleTableSize; i++)
{
if (HandleTable[i].Object != NULL)
- CsrReleaseObjectByPointer(HandleTable[i].Object);
+ Win32CsrReleaseObjectByPointer(HandleTable[i].Object);
}
RtlFreeHeap(Win32CsrApiHeap, 0, HandleTable);
if (Console != NULL)
{
- RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)&Console->Header.Lock);
+ EnterCriticalSection(&Console->Header.Lock);
RemoveEntryList(&ProcessData->ProcessEntry);
- RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)&Console->Header.Lock);
- CsrReleaseObjectByPointer(&Console->Header);
+ LeaveCriticalSection(&Console->Header.Lock);
+ Win32CsrReleaseObjectByPointer(&Console->Header);
return STATUS_SUCCESS;
}
}
NTSTATUS
-WINAPI
-CsrInsertObject(
+FASTCALL
+Win32CsrInsertObject(
PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object,
BOOL Inheritable)
{
ULONG i;
- PVOID* Block;
+ PCSRSS_HANDLE Block;
RtlEnterCriticalSection(&ProcessData->HandleTableLock);
RtlCopyMemory(Block,
ProcessData->HandleTable,
ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE));
- Block = _InterlockedExchangePointer((void* volatile)&ProcessData->HandleTable, Block);
- RtlFreeHeap( Win32CsrApiHeap, 0, Block );
+ RtlFreeHeap(Win32CsrApiHeap, 0, ProcessData->HandleTable);
+ ProcessData->HandleTable = Block;
ProcessData->HandleTableSize += 64;
}
ProcessData->HandleTable[i].Object = Object;
NTSTATUS
WINAPI
-CsrDuplicateHandleTable(
+Win32CsrDuplicateHandleTable(
PCSRSS_PROCESS_DATA SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData)
{
return(STATUS_SUCCESS);
}
-NTSTATUS
-WINAPI
-CsrVerifyObject(
- PCSRSS_PROCESS_DATA ProcessData,
- HANDLE Handle)
-{
- ULONG_PTR h = (ULONG_PTR)Handle >> 2;
-
- if (h >= ProcessData->HandleTableSize ||
- ProcessData->HandleTable[h].Object == NULL)
- {
- return STATUS_INVALID_HANDLE;
- }
-
- return STATUS_SUCCESS;
-}
-
CSR_API(CsrGetInputHandle)
{
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
if (ProcessData->Console)
{
- Request->Status = CsrInsertObject(ProcessData,
- &Request->Data.GetInputHandleRequest.InputHandle,
- (Object_t *)ProcessData->Console,
- Request->Data.GetInputHandleRequest.Access,
- Request->Data.GetInputHandleRequest.Inheritable);
+ Request->Status = Win32CsrInsertObject(ProcessData,
+ &Request->Data.GetInputHandleRequest.InputHandle,
+ &ProcessData->Console->Header,
+ Request->Data.GetInputHandleRequest.Access,
+ Request->Data.GetInputHandleRequest.Inheritable);
}
else
{
if (ProcessData->Console)
{
- Request->Status = CsrInsertObject(ProcessData,
- &Request->Data.GetOutputHandleRequest.OutputHandle,
- &ProcessData->Console->ActiveBuffer->Header,
- Request->Data.GetOutputHandleRequest.Access,
- Request->Data.GetOutputHandleRequest.Inheritable);
+ Request->Status = Win32CsrInsertObject(ProcessData,
+ &Request->Data.GetOutputHandleRequest.OutputHandle,
+ &ProcessData->Console->ActiveBuffer->Header,
+ Request->Data.GetOutputHandleRequest.Access,
+ Request->Data.GetOutputHandleRequest.Inheritable);
}
else
{
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- return CsrReleaseObject(ProcessData, Request->Data.CloseHandleRequest.Handle);
+ return Win32CsrReleaseObject(ProcessData, Request->Data.CloseHandleRequest.Handle);
}
CSR_API(CsrVerifyHandle)
{
+ ULONG_PTR Index;
+ NTSTATUS Status = STATUS_SUCCESS;
+
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
- Request->Status = CsrVerifyObject(ProcessData, Request->Data.VerifyHandleRequest.Handle);
- if (!NT_SUCCESS(Request->Status))
+ Index = (ULONG_PTR)Request->Data.VerifyHandleRequest.Handle >> 2;
+ RtlEnterCriticalSection(&ProcessData->HandleTableLock);
+ if (Index >= ProcessData->HandleTableSize ||
+ ProcessData->HandleTable[Index].Object == NULL)
{
- DPRINT("CsrVerifyObject failed, status=%x\n", Request->Status);
+ DPRINT("CsrVerifyObject failed\n");
+ Status = STATUS_INVALID_HANDLE;
}
+ RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
- return Request->Status;
+ return Status;
}
CSR_API(CsrDuplicateHandle)
}
}
- Request->Status = CsrInsertObject(ProcessData,
- &Request->Data.DuplicateHandleRequest.Handle,
- Entry->Object,
- DesiredAccess,
- Request->Data.DuplicateHandleRequest.Inheritable);
+ Request->Status = Win32CsrInsertObject(ProcessData,
+ &Request->Data.DuplicateHandleRequest.Handle,
+ Entry->Object,
+ DesiredAccess,
+ Request->Data.DuplicateHandleRequest.Inheritable);
if (NT_SUCCESS(Request->Status)
&& Request->Data.DuplicateHandleRequest.Options & DUPLICATE_CLOSE_SOURCE)
{
extern HANDLE Win32CsrApiHeap;
extern HINSTANCE Win32CsrDllHandle;
+typedef struct Object_tt
+{
+ LONG Type;
+ LONG ReferenceCount;
+ CRITICAL_SECTION Lock;
+} Object_t;
+
+typedef struct _CSRSS_HANDLE
+{
+ Object_t *Object;
+ DWORD Access;
+ BOOL Inheritable;
+} CSRSS_HANDLE, *PCSRSS_HANDLE;
+
+typedef VOID (WINAPI *CSR_CLEANUP_OBJECT_PROC)(Object_t *Object);
+
+typedef struct tagCSRSS_OBJECT_DEFINITION
+{
+ LONG Type;
+ CSR_CLEANUP_OBJECT_PROC CsrCleanupObjectProc;
+} CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION;
+
+/* handle.c */
NTSTATUS FASTCALL Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
Object_t *Object,
DWORD Access,
long Type);
VOID FASTCALL Win32CsrUnlockObject(Object_t *Object);
-
NTSTATUS FASTCALL Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object,
NTSTATUS FASTCALL Win32CsrReleaseObjectByPointer(Object_t *Object);
NTSTATUS FASTCALL Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object);
-NTSTATUS FASTCALL Win32CsrReleaseConsole(PCSRSS_PROCESS_DATA ProcessData);
+NTSTATUS WINAPI Win32CsrReleaseConsole(PCSRSS_PROCESS_DATA ProcessData);
+NTSTATUS WINAPI Win32CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData,
+ PCSRSS_PROCESS_DATA TargetProcessData);
+CSR_API(CsrGetInputHandle);
+CSR_API(CsrGetOutputHandle);
+CSR_API(CsrCloseHandle);
+CSR_API(CsrVerifyHandle);
+CSR_API(CsrDuplicateHandle);
+CSR_API(CsrGetInputWaitHandle);
+
NTSTATUS FASTCALL Win32CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc,
PVOID Context);
+/* exitros.c */
+CSR_API(CsrExitReactos);
+CSR_API(CsrSetLogonNotifyWindow);
+CSR_API(CsrRegisterLogonProcess);
+
+
/* EOF */
<file>dllmain.c</file>
<file>exitros.c</file>
<file>guiconsole.c</file>
- <file>handle.c</file>
+ <file>handle.c</file>
<file>harderror.c</file>
<file>tuiconsole.c</file>
<file>appswitch.c</file>
projects / reactos.git / commitdiff