Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-10-15 05:37:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[WIN32CSR] Clean up the debris from r47314: Removed some redundant code, reorganized headers, fixed win32csr.rbuild indentation

Browse source 
svn path=/trunk/; revision=47315
This commit is contained in:
Jeffrey Morlan 2010-05-23 00:51:29 +00:00
parent 7d27afbe96
commit 8686d42f93
8 changed files with 144 additions and 255 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/subsystems/win32/csrss/csrsrv/srv.h
View file

@ -17,5 +17,4 @@
/* Internal CSRSS Headers */ /* Internal CSRSS Headers */
#include <api.h> #include <api.h>
#include <conio.h>
#include <csrplugin.h> #include <csrplugin.h>

75
reactos/subsystems/win32/csrss/include/api.h
View file

@ -44,31 +44,6 @@ typedef enum _CSR_PROCESS_FLAGS
CsrProcessIsConsoleApp = 0x800 CsrProcessIsConsoleApp = 0x800
} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS; } 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 typedef struct _CSRSS_PROCESS_DATA
{ {
struct tagCSRSS_CONSOLE *Console; struct tagCSRSS_CONSOLE *Console;
@ -76,7 +51,7 @@ typedef struct _CSRSS_PROCESS_DATA
BOOL bInheritHandles; BOOL bInheritHandles;
RTL_CRITICAL_SECTION HandleTableLock; RTL_CRITICAL_SECTION HandleTableLock;
ULONG HandleTableSize; ULONG HandleTableSize;
PCSRSS_HANDLE HandleTable; struct _CSRSS_HANDLE *HandleTable;
HANDLE ProcessId; HANDLE ProcessId;
DWORD ProcessGroup; DWORD ProcessGroup;
HANDLE Process; HANDLE Process;
@ -109,14 +84,6 @@ typedef struct _CSR_THREAD
ULONG ImpersonationCount; ULONG ImpersonationCount;
} CSR_THREAD, *PCSR_THREAD; } 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, typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request); PCSR_API_MESSAGE Request);
@ -143,33 +110,25 @@ PCSR_API_MESSAGE Request)
/* init.c */ /* init.c */
extern HANDLE hBootstrapOk; extern HANDLE hBootstrapOk;
NTSTATUS NTAPI CsrServerInitialization(ULONG ArgumentCount, PCHAR Arguments[]);
/* api/process.c */ /* api/process.c */
CSR_API(CsrConnectProcess); CSR_API(CsrConnectProcess);
CSR_API(CsrCreateProcess); CSR_API(CsrCreateProcess);
CSR_API(CsrTerminateProcess); CSR_API(CsrTerminateProcess);
CSR_API(CsrSrvCreateThread); CSR_API(CsrSrvCreateThread);
CSR_API(CsrGetShutdownParameters);
/* print.c */ CSR_API(CsrSetShutdownParameters);
VOID WINAPI DisplayString(LPCWSTR lpwString);
VOID WINAPI PrintString (char* fmt, ...);
/* api/wapi.c */ /* api/wapi.c */
NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions); NTSTATUS FASTCALL CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions);
VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData, VOID FASTCALL CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
PCSR_API_MESSAGE Request); PCSR_API_MESSAGE Request);
DWORD WINAPI ServerApiPortThread (PVOID PortHandle);
DWORD WINAPI ServerSbApiPortThread (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; extern HANDLE CsrssApiHeap;
/* api/conio.c */
VOID WINAPI CsrInitConsoleSupport(VOID);
/* api/process.c */ /* api/process.c */
typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData, typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData,
PVOID Context); PVOID Context);
@ -185,34 +144,10 @@ NTSTATUS NTAPI CsrLockProcessByClientId(IN HANDLE Pid, OUT PCSRSS_PROCESS_DATA *
NTSTATUS NTAPI CsrCreateThread(IN PCSRSS_PROCESS_DATA CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId); NTSTATUS NTAPI CsrCreateThread(IN PCSRSS_PROCESS_DATA CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId);
NTSTATUS NTAPI CsrUnlockProcess(IN PCSRSS_PROCESS_DATA CsrProcess); 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 //hack
VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread); 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 */ /* api/user.c */
CSR_API(CsrRegisterServicesProcess); CSR_API(CsrRegisterServicesProcess);
CSR_API(CsrExitReactos);
CSR_API(CsrGetShutdownParameters);
CSR_API(CsrSetShutdownParameters);
CSR_API(CsrSetLogonNotifyWindow);
CSR_API(CsrRegisterLogonProcess);
/* EOF */ /* EOF */

12
reactos/subsystems/win32/csrss/win32csr/conio.h
View file

@ -48,6 +48,8 @@ typedef struct tagCSRSS_SCREEN_BUFFER
USHORT Mode; USHORT Mode;
} CSRSS_SCREEN_BUFFER, *PCSRSS_SCREEN_BUFFER; } CSRSS_SCREEN_BUFFER, *PCSRSS_SCREEN_BUFFER;
typedef struct tagCSRSS_CONSOLE *PCSRSS_CONSOLE;
typedef struct tagCSRSS_CONSOLE_VTBL typedef struct tagCSRSS_CONSOLE_VTBL
{ {
VOID (WINAPI *InitScreenBuffer)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer); VOID (WINAPI *InitScreenBuffer)(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER ScreenBuffer);
@ -88,9 +90,19 @@ typedef struct tagCSRSS_CONSOLE
struct tagALIAS_HEADER *Aliases; struct tagALIAS_HEADER *Aliases;
} CSRSS_CONSOLE; } 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); NTSTATUS FASTCALL ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console);
VOID WINAPI ConioDeleteConsole(Object_t *Object); VOID WINAPI ConioDeleteConsole(Object_t *Object);
VOID WINAPI ConioDeleteScreenBuffer(Object_t *Buffer); VOID WINAPI ConioDeleteScreenBuffer(Object_t *Buffer);
VOID WINAPI CsrInitConsoleSupport(VOID);
void WINAPI ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode); void WINAPI ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode);
PBYTE FASTCALL ConioCoordToPointer(PCSRSS_SCREEN_BUFFER Buf, ULONG X, ULONG Y); PBYTE FASTCALL ConioCoordToPointer(PCSRSS_SCREEN_BUFFER Buf, ULONG X, ULONG Y);
VOID FASTCALL ConioDrawConsole(PCSRSS_CONSOLE Console); VOID FASTCALL ConioDrawConsole(PCSRSS_CONSOLE Console);

0
reactos/subsystems/win32/csrss/include/desktopbg.h → reactos/subsystems/win32/csrss/win32csr/desktopbg.h
View file

83
reactos/subsystems/win32/csrss/win32csr/dllmain.c
View file

@ -84,13 +84,6 @@ static CSRSS_API_DEFINITION Win32CsrApiDefinitions[] =
{ 0, 0, NULL } { 0, 0, NULL }
}; };
static CSRSS_OBJECT_DEFINITION Win32CsrObjectDefinitions[] =
{
{ CONIO_CONSOLE_MAGIC, ConioDeleteConsole },
{ CONIO_SCREEN_BUFFER_MAGIC, ConioDeleteScreenBuffer },
{ 0, NULL }
};
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
BOOL WINAPI BOOL WINAPI
@ -107,77 +100,6 @@ DllMain(HANDLE hDll,
return TRUE; 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 NTSTATUS FASTCALL
Win32CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, Win32CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc,
PVOID Context) PVOID Context)
@ -207,13 +129,12 @@ Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
PrivateCsrssManualGuiCheck(0); PrivateCsrssManualGuiCheck(0);
CsrInitConsoleSupport(); CsrInitConsoleSupport();
CsrRegisterObjectDefinitions(Win32CsrObjectDefinitions);
*ApiDefinitions = Win32CsrApiDefinitions; *ApiDefinitions = Win32CsrApiDefinitions;
ServerProcs->InitCompleteProc = Win32CsrInitComplete; ServerProcs->InitCompleteProc = Win32CsrInitComplete;
ServerProcs->HardErrorProc = Win32CsrHardError; ServerProcs->HardErrorProc = Win32CsrHardError;
ServerProcs->ProcessInheritProc = CsrDuplicateHandleTable; ServerProcs->ProcessInheritProc = Win32CsrDuplicateHandleTable;
ServerProcs->ProcessDeletedProc = CsrReleaseConsole; ServerProcs->ProcessDeletedProc = Win32CsrReleaseConsole;
return TRUE; return TRUE;
} }

185
reactos/subsystems/win32/csrss/win32csr/handle.c
View file

@ -16,8 +16,12 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
static unsigned ObjectDefinitionsCount = 0; static unsigned ObjectDefinitionsCount = 2;
static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL; static CSRSS_OBJECT_DEFINITION ObjectDefinitions[] =
{
{ CONIO_CONSOLE_MAGIC, ConioDeleteConsole },
{ CONIO_SCREEN_BUFFER_MAGIC, ConioDeleteScreenBuffer },
};
static static
BOOL BOOL
@ -26,52 +30,9 @@ CsrIsConsoleHandle(HANDLE Handle)
return ((ULONG_PTR)Handle & 0x10000003) == 0x3; return ((ULONG_PTR)Handle & 0x10000003) == 0x3;
} }
NTSTATUS NTSTATUS
FASTCALL FASTCALL
CsrRegisterObjectDefinitions( Win32CsrGetObject(
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(
PCSRSS_PROCESS_DATA ProcessData, PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle, HANDLE Handle,
Object_t **Object, Object_t **Object,
@ -99,8 +60,8 @@ CsrGetObject(
NTSTATUS NTSTATUS
WINAPI FASTCALL
CsrReleaseObjectByPointer( Win32CsrReleaseObjectByPointer(
Object_t *Object) Object_t *Object)
{ {
unsigned DefIndex; unsigned DefIndex;
@ -123,10 +84,9 @@ CsrReleaseObjectByPointer(
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS NTSTATUS
WINAPI FASTCALL
CsrReleaseObject( Win32CsrReleaseObject(
PCSRSS_PROCESS_DATA ProcessData, PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle) HANDLE Handle)
{ {
@ -143,12 +103,47 @@ CsrReleaseObject(
ProcessData->HandleTable[h].Object = NULL; ProcessData->HandleTable[h].Object = NULL;
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); 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 NTSTATUS
WINAPI WINAPI
CsrReleaseConsole( Win32CsrReleaseConsole(
PCSRSS_PROCESS_DATA ProcessData) PCSRSS_PROCESS_DATA ProcessData)
{ {
ULONG HandleTableSize; ULONG HandleTableSize;
@ -169,16 +164,16 @@ CsrReleaseConsole(
for (i = 0; i < HandleTableSize; i++) for (i = 0; i < HandleTableSize; i++)
{ {
if (HandleTable[i].Object != NULL) if (HandleTable[i].Object != NULL)
CsrReleaseObjectByPointer(HandleTable[i].Object); Win32CsrReleaseObjectByPointer(HandleTable[i].Object);
} }
RtlFreeHeap(Win32CsrApiHeap, 0, HandleTable); RtlFreeHeap(Win32CsrApiHeap, 0, HandleTable);
if (Console != NULL) if (Console != NULL)
{ {
RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)&Console->Header.Lock); EnterCriticalSection(&Console->Header.Lock);
RemoveEntryList(&ProcessData->ProcessEntry); RemoveEntryList(&ProcessData->ProcessEntry);
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)&Console->Header.Lock); LeaveCriticalSection(&Console->Header.Lock);
CsrReleaseObjectByPointer(&Console->Header); Win32CsrReleaseObjectByPointer(&Console->Header);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -186,8 +181,8 @@ CsrReleaseConsole(
} }
NTSTATUS NTSTATUS
WINAPI FASTCALL
CsrInsertObject( Win32CsrInsertObject(
PCSRSS_PROCESS_DATA ProcessData, PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle, PHANDLE Handle,
Object_t *Object, Object_t *Object,
@ -195,7 +190,7 @@ CsrInsertObject(
BOOL Inheritable) BOOL Inheritable)
{ {
ULONG i; ULONG i;
PVOID* Block; PCSRSS_HANDLE Block;
RtlEnterCriticalSection(&ProcessData->HandleTableLock); RtlEnterCriticalSection(&ProcessData->HandleTableLock);
@ -219,8 +214,8 @@ CsrInsertObject(
RtlCopyMemory(Block, RtlCopyMemory(Block,
ProcessData->HandleTable, ProcessData->HandleTable,
ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE)); ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE));
Block = _InterlockedExchangePointer((void* volatile)&ProcessData->HandleTable, Block); RtlFreeHeap(Win32CsrApiHeap, 0, ProcessData->HandleTable);
RtlFreeHeap( Win32CsrApiHeap, 0, Block ); ProcessData->HandleTable = Block;
ProcessData->HandleTableSize += 64; ProcessData->HandleTableSize += 64;
} }
ProcessData->HandleTable[i].Object = Object; ProcessData->HandleTable[i].Object = Object;
@ -234,7 +229,7 @@ CsrInsertObject(
NTSTATUS NTSTATUS
WINAPI WINAPI
CsrDuplicateHandleTable( Win32CsrDuplicateHandleTable(
PCSRSS_PROCESS_DATA SourceProcessData, PCSRSS_PROCESS_DATA SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData) PCSRSS_PROCESS_DATA TargetProcessData)
{ {
@ -272,23 +267,6 @@ CsrDuplicateHandleTable(
return(STATUS_SUCCESS); 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) CSR_API(CsrGetInputHandle)
{ {
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
@ -296,11 +274,11 @@ CSR_API(CsrGetInputHandle)
if (ProcessData->Console) if (ProcessData->Console)
{ {
Request->Status = CsrInsertObject(ProcessData, Request->Status = Win32CsrInsertObject(ProcessData,
&Request->Data.GetInputHandleRequest.InputHandle, &Request->Data.GetInputHandleRequest.InputHandle,
(Object_t *)ProcessData->Console, &ProcessData->Console->Header,
Request->Data.GetInputHandleRequest.Access, Request->Data.GetInputHandleRequest.Access,
Request->Data.GetInputHandleRequest.Inheritable); Request->Data.GetInputHandleRequest.Inheritable);
} }
else else
{ {
@ -318,11 +296,11 @@ CSR_API(CsrGetOutputHandle)
if (ProcessData->Console) if (ProcessData->Console)
{ {
Request->Status = CsrInsertObject(ProcessData, Request->Status = Win32CsrInsertObject(ProcessData,
&Request->Data.GetOutputHandleRequest.OutputHandle, &Request->Data.GetOutputHandleRequest.OutputHandle,
&ProcessData->Console->ActiveBuffer->Header, &ProcessData->Console->ActiveBuffer->Header,
Request->Data.GetOutputHandleRequest.Access, Request->Data.GetOutputHandleRequest.Access,
Request->Data.GetOutputHandleRequest.Inheritable); Request->Data.GetOutputHandleRequest.Inheritable);
} }
else else
{ {
@ -338,21 +316,28 @@ CSR_API(CsrCloseHandle)
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_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) CSR_API(CsrVerifyHandle)
{ {
ULONG_PTR Index;
NTSTATUS Status = STATUS_SUCCESS;
Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE); Request->Header.u1.s1.DataLength = sizeof(CSR_API_MESSAGE) - sizeof(PORT_MESSAGE);
Request->Status = CsrVerifyObject(ProcessData, Request->Data.VerifyHandleRequest.Handle); Index = (ULONG_PTR)Request->Data.VerifyHandleRequest.Handle >> 2;
if (!NT_SUCCESS(Request->Status)) 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) CSR_API(CsrDuplicateHandle)
@ -391,11 +376,11 @@ CSR_API(CsrDuplicateHandle)
} }
} }
Request->Status = CsrInsertObject(ProcessData, Request->Status = Win32CsrInsertObject(ProcessData,
&Request->Data.DuplicateHandleRequest.Handle, &Request->Data.DuplicateHandleRequest.Handle,
Entry->Object, Entry->Object,
DesiredAccess, DesiredAccess,
Request->Data.DuplicateHandleRequest.Inheritable); Request->Data.DuplicateHandleRequest.Inheritable);
if (NT_SUCCESS(Request->Status) if (NT_SUCCESS(Request->Status)
&& Request->Data.DuplicateHandleRequest.Options & DUPLICATE_CLOSE_SOURCE) && Request->Data.DuplicateHandleRequest.Options & DUPLICATE_CLOSE_SOURCE)
{ {

41
reactos/subsystems/win32/csrss/win32csr/win32csr.h
View file

@ -14,6 +14,29 @@
extern HANDLE Win32CsrApiHeap; extern HANDLE Win32CsrApiHeap;
extern HINSTANCE Win32CsrDllHandle; 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, NTSTATUS FASTCALL Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle, PHANDLE Handle,
Object_t *Object, Object_t *Object,
@ -25,7 +48,6 @@ NTSTATUS FASTCALL Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData,
DWORD Access, DWORD Access,
long Type); long Type);
VOID FASTCALL Win32CsrUnlockObject(Object_t *Object); VOID FASTCALL Win32CsrUnlockObject(Object_t *Object);
NTSTATUS FASTCALL Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS FASTCALL Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle, HANDLE Handle,
Object_t **Object, Object_t **Object,
@ -33,8 +55,23 @@ NTSTATUS FASTCALL Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
NTSTATUS FASTCALL Win32CsrReleaseObjectByPointer(Object_t *Object); NTSTATUS FASTCALL Win32CsrReleaseObjectByPointer(Object_t *Object);
NTSTATUS FASTCALL Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS FASTCALL Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Object); 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, NTSTATUS FASTCALL Win32CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc,
PVOID Context); PVOID Context);
/* exitros.c */
CSR_API(CsrExitReactos);
CSR_API(CsrSetLogonNotifyWindow);
CSR_API(CsrRegisterLogonProcess);
/* EOF */ /* EOF */

2
reactos/subsystems/win32/csrss/win32csr/win32csr.rbuild
View file

@ -22,7 +22,7 @@
<file>dllmain.c</file> <file>dllmain.c</file>
<file>exitros.c</file> <file>exitros.c</file>
<file>guiconsole.c</file> <file>guiconsole.c</file>
<file>handle.c</file> <file>handle.c</file>
<file>harderror.c</file> <file>harderror.c</file>
<file>tuiconsole.c</file> <file>tuiconsole.c</file>
<file>appswitch.c</file> <file>appswitch.c</file>