Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-06 20:55:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

[CSRSRV/WIN32CSR]: No code change, but rename CSRSS_PROCESS_DATA to CSR_PROCESS and all the right fields -- put ReactOS-specific fields at the end. Do all the right renames needed for compilation. No functionality change.

Browse source 
svn path=/trunk/; revision=55617
This commit is contained in:
Alex Ionescu 2012-02-15 20:29:08 +00:00
parent 14471474b7
commit 4b16693aed
18 changed files with 200 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
reactos/subsystems/win32/csrss/csrsrv/api/process.c
View file

@ -18,15 +18,15 @@
#define CsrAcquireProcessLock() LOCK #define CsrAcquireProcessLock() LOCK
#define CsrReleaseProcessLock() UNLOCK #define CsrReleaseProcessLock() UNLOCK
extern NTSTATUS CallProcessInherit(PCSRSS_PROCESS_DATA, PCSRSS_PROCESS_DATA); extern NTSTATUS CallProcessInherit(PCSR_PROCESS, PCSR_PROCESS);
extern NTSTATUS CallProcessDeleted(PCSRSS_PROCESS_DATA); extern NTSTATUS CallProcessDeleted(PCSR_PROCESS);
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
static ULONG NrProcess; static ULONG NrProcess;
PCSRSS_PROCESS_DATA ProcessData[256]; PCSR_PROCESS ProcessData[256];
RTL_CRITICAL_SECTION ProcessDataLock; RTL_CRITICAL_SECTION ProcessDataLock;
extern PCSRSS_PROCESS_DATA CsrRootProcess; extern PCSR_PROCESS CsrRootProcess;
extern LIST_ENTRY CsrThreadHashTable[256]; extern LIST_ENTRY CsrThreadHashTable[256];
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
@ -44,10 +44,10 @@ VOID WINAPI CsrInitProcessData(VOID)
for (i = 0; i < 256; i++) InitializeListHead(&CsrThreadHashTable[i]); for (i = 0; i < 256; i++) InitializeListHead(&CsrThreadHashTable[i]);
} }
PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId) PCSR_PROCESS WINAPI CsrGetProcessData(HANDLE ProcessId)
{ {
ULONG hash; ULONG hash;
PCSRSS_PROCESS_DATA pProcessData; PCSR_PROCESS pProcessData;
hash = ((ULONG_PTR)ProcessId >> 2) % (sizeof(ProcessData) / sizeof(*ProcessData)); hash = ((ULONG_PTR)ProcessId >> 2) % (sizeof(ProcessData) / sizeof(*ProcessData));
@ -55,7 +55,7 @@ PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId)
pProcessData = ProcessData[hash]; pProcessData = ProcessData[hash];
while (pProcessData && pProcessData->ProcessId != ProcessId) while (pProcessData && pProcessData->ClientId.UniqueProcess != ProcessId)
{ {
pProcessData = pProcessData->next; pProcessData = pProcessData->next;
} }
@ -63,10 +63,10 @@ PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId)
return pProcessData; return pProcessData;
} }
PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId) PCSR_PROCESS WINAPI CsrCreateProcessData(HANDLE ProcessId)
{ {
ULONG hash; ULONG hash;
PCSRSS_PROCESS_DATA pProcessData; PCSR_PROCESS pProcessData;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
CLIENT_ID ClientId; CLIENT_ID ClientId;
NTSTATUS Status; NTSTATUS Status;
@ -77,7 +77,7 @@ PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
pProcessData = ProcessData[hash]; pProcessData = ProcessData[hash];
while (pProcessData && pProcessData->ProcessId != ProcessId) while (pProcessData && pProcessData->ClientId.UniqueProcess != ProcessId)
{ {
pProcessData = pProcessData->next; pProcessData = pProcessData->next;
} }
@ -85,15 +85,15 @@ PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
{ {
pProcessData = RtlAllocateHeap(CsrHeap, pProcessData = RtlAllocateHeap(CsrHeap,
HEAP_ZERO_MEMORY, HEAP_ZERO_MEMORY,
sizeof(CSRSS_PROCESS_DATA)); sizeof(CSR_PROCESS));
if (pProcessData) if (pProcessData)
{ {
pProcessData->ProcessId = ProcessId; pProcessData->ClientId.UniqueProcess = ProcessId;
pProcessData->next = ProcessData[hash]; pProcessData->next = ProcessData[hash];
ProcessData[hash] = pProcessData; ProcessData[hash] = pProcessData;
ClientId.UniqueThread = NULL; ClientId.UniqueThread = NULL;
ClientId.UniqueProcess = pProcessData->ProcessId; ClientId.UniqueProcess = pProcessData->ClientId.UniqueProcess;
InitializeObjectAttributes(&ObjectAttributes, InitializeObjectAttributes(&ObjectAttributes,
NULL, NULL,
0, 0,
@ -101,11 +101,11 @@ PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
NULL); NULL);
/* using OpenProcess is not optimal due to HANDLE vs. DWORD PIDs... */ /* using OpenProcess is not optimal due to HANDLE vs. DWORD PIDs... */
Status = NtOpenProcess(&pProcessData->Process, Status = NtOpenProcess(&pProcessData->ProcessHandle,
PROCESS_ALL_ACCESS, PROCESS_ALL_ACCESS,
&ObjectAttributes, &ObjectAttributes,
&ClientId); &ClientId);
DPRINT("CSR Process: %p Handle: %p\n", pProcessData, pProcessData->Process); DPRINT("CSR Process: %p Handle: %p\n", pProcessData, pProcessData->ProcessHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ProcessData[hash] = pProcessData->next; ProcessData[hash] = pProcessData->next;
@ -129,7 +129,7 @@ PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
} }
else else
{ {
pProcessData->Terminated = FALSE; pProcessData->Flags = ~CsrProcessTerminated;
/* Set default shutdown parameters */ /* Set default shutdown parameters */
pProcessData->ShutdownLevel = 0x280; pProcessData->ShutdownLevel = 0x280;
@ -144,7 +144,7 @@ PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId)
NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid) NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
{ {
ULONG hash; ULONG hash;
PCSRSS_PROCESS_DATA pProcessData, *pPrevLink; PCSR_PROCESS pProcessData, *pPrevLink;
HANDLE Process; HANDLE Process;
PLIST_ENTRY NextEntry; PLIST_ENTRY NextEntry;
PCSR_THREAD Thread; PCSR_THREAD Thread;
@ -154,7 +154,7 @@ NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
LOCK; LOCK;
while ((pProcessData = *pPrevLink) && pProcessData->ProcessId != Pid) while ((pProcessData = *pPrevLink) && pProcessData->ClientId.UniqueProcess != Pid)
{ {
pPrevLink = &pProcessData->next; pPrevLink = &pProcessData->next;
} }
@ -162,7 +162,7 @@ NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
if (pProcessData) if (pProcessData)
{ {
DPRINT("CsrFreeProcessData pid: %d\n", Pid); DPRINT("CsrFreeProcessData pid: %d\n", Pid);
Process = pProcessData->Process; Process = pProcessData->ProcessHandle;
CallProcessDeleted(pProcessData); CallProcessDeleted(pProcessData);
/* Dereference all process threads */ /* Dereference all process threads */
@ -175,14 +175,14 @@ NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
CsrThreadRefcountZero(Thread); CsrThreadRefcountZero(Thread);
} }
if (pProcessData->CsrSectionViewBase) if (pProcessData->ClientViewBase)
{ {
NtUnmapViewOfSection(NtCurrentProcess(), pProcessData->CsrSectionViewBase); NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)pProcessData->ClientViewBase);
} }
if (pProcessData->ServerCommunicationPort) if (pProcessData->ClientPort)
{ {
NtClose(pProcessData->ServerCommunicationPort); NtClose(pProcessData->ClientPort);
} }
*pPrevLink = pProcessData->next; *pPrevLink = pProcessData->next;
@ -206,7 +206,7 @@ NTSTATUS WINAPI CsrFreeProcessData(HANDLE Pid)
CSR_API(CsrCreateProcess) CSR_API(CsrCreateProcess)
{ {
PCSRSS_PROCESS_DATA NewProcessData; PCSR_PROCESS NewProcessData;
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->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE); Request->Header.u1.s1.TotalLength = sizeof(CSR_API_MESSAGE);
@ -229,11 +229,11 @@ CSR_API(CsrCreateProcess)
if (Request->Data.CreateProcessRequest.Flags & CREATE_NEW_PROCESS_GROUP) if (Request->Data.CreateProcessRequest.Flags & CREATE_NEW_PROCESS_GROUP)
{ {
NewProcessData->ProcessGroup = (DWORD)(ULONG_PTR)NewProcessData->ProcessId; NewProcessData->ProcessGroupId = (DWORD)(ULONG_PTR)NewProcessData->ClientId.UniqueProcess;
} }
else else
{ {
NewProcessData->ProcessGroup = ProcessData->ProcessGroup; NewProcessData->ProcessGroupId = ProcessData->ProcessGroupId;
} }
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
@ -244,7 +244,7 @@ CSR_API(CsrSrvCreateThread)
PCSR_THREAD CurrentThread; PCSR_THREAD CurrentThread;
HANDLE ThreadHandle; HANDLE ThreadHandle;
NTSTATUS Status; NTSTATUS Status;
PCSRSS_PROCESS_DATA CsrProcess; PCSR_PROCESS CsrProcess;
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);
@ -253,11 +253,11 @@ CSR_API(CsrSrvCreateThread)
CsrProcess = CurrentThread->Process; CsrProcess = CurrentThread->Process;
// DPRINT1("Current thread: %p %p\n", CurrentThread, CsrProcess); // DPRINT1("Current thread: %p %p\n", CurrentThread, CsrProcess);
// DPRINT1("Request CID: %lx %lx %lx\n", // DPRINT1("Request CID: %lx %lx %lx\n",
// CsrProcess->ProcessId, // CsrProcess->ClientId.UniqueProcess,
// NtCurrentTeb()->ClientId.UniqueProcess, // NtCurrentTeb()->ClientId.UniqueProcess,
// Request->Data.CreateThreadRequest.ClientId.UniqueProcess); // Request->Data.CreateThreadRequest.ClientId.UniqueProcess);
if (CsrProcess->ProcessId != Request->Data.CreateThreadRequest.ClientId.UniqueProcess) if (CsrProcess->ClientId.UniqueProcess != Request->Data.CreateThreadRequest.ClientId.UniqueProcess)
{ {
if (Request->Data.CreateThreadRequest.ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess) if (Request->Data.CreateThreadRequest.ClientId.UniqueProcess == NtCurrentTeb()->ClientId.UniqueProcess)
{ {
@ -270,12 +270,12 @@ CSR_API(CsrSrvCreateThread)
if (!NT_SUCCESS(Status)) return Status; if (!NT_SUCCESS(Status)) return Status;
} }
// DPRINT1("PIDs: %lx %lx\n", CurrentThread->Process->ProcessId, CsrProcess->ProcessId); // DPRINT1("PIDs: %lx %lx\n", CurrentThread->Process->ClientId.UniqueProcess, CsrProcess->ClientId.UniqueProcess);
// DPRINT1("Thread handle is: %lx Process Handle is: %lx %lx\n", // DPRINT1("Thread handle is: %lx Process Handle is: %lx %lx\n",
// Request->Data.CreateThreadRequest.ThreadHandle, // Request->Data.CreateThreadRequest.ThreadHandle,
// CurrentThread->Process->Process, // CurrentThread->Process->ProcessHandle,
// CsrProcess->Process); // CsrProcess->Process);
Status = NtDuplicateObject(CsrProcess->Process, Status = NtDuplicateObject(CsrProcess->ProcessHandle,
Request->Data.CreateThreadRequest.ThreadHandle, Request->Data.CreateThreadRequest.ThreadHandle,
NtCurrentProcess(), NtCurrentProcess(),
&ThreadHandle, &ThreadHandle,
@ -285,7 +285,7 @@ CSR_API(CsrSrvCreateThread)
//DPRINT1("Duplicate status: %lx\n", Status); //DPRINT1("Duplicate status: %lx\n", Status);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
Status = NtDuplicateObject(CurrentThread->Process->Process, Status = NtDuplicateObject(CurrentThread->Process->ProcessHandle,
Request->Data.CreateThreadRequest.ThreadHandle, Request->Data.CreateThreadRequest.ThreadHandle,
NtCurrentProcess(), NtCurrentProcess(),
&ThreadHandle, &ThreadHandle,
@ -327,7 +327,7 @@ CSR_API(CsrTerminateProcess)
} }
ProcessData->Terminated = TRUE; ProcessData->Flags |= CsrProcessTerminated;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }

32
reactos/subsystems/win32/csrss/csrsrv/api/wapi.c
View file

@ -72,7 +72,7 @@ CsrApiRegisterDefinitions(PCSRSS_API_DEFINITION NewDefinitions)
VOID VOID
FASTCALL FASTCALL
CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData, CsrApiCallHandler(PCSR_PROCESS ProcessData,
PCSR_API_MESSAGE Request) PCSR_API_MESSAGE Request)
{ {
unsigned DefIndex; unsigned DefIndex;
@ -108,13 +108,13 @@ CsrApiCallHandler(PCSRSS_PROCESS_DATA ProcessData,
} }
BOOL BOOL
CallHardError(IN PCSRSS_PROCESS_DATA ProcessData, CallHardError(IN PCSR_PROCESS ProcessData,
IN PHARDERROR_MSG HardErrorMessage); IN PHARDERROR_MSG HardErrorMessage);
static static
VOID VOID
NTAPI NTAPI
CsrHandleHardError(IN PCSRSS_PROCESS_DATA ProcessData, CsrHandleHardError(IN PCSR_PROCESS ProcessData,
IN OUT PHARDERROR_MSG Message) IN OUT PHARDERROR_MSG Message)
{ {
DPRINT1("CSR: received hard error %lx\n", Message->Status); DPRINT1("CSR: received hard error %lx\n", Message->Status);
@ -275,7 +275,7 @@ CsrSrvCreateSharedSection(IN PCHAR ParameterValue)
*--*/ *--*/
NTSTATUS NTSTATUS
NTAPI NTAPI
CsrSrvAttachSharedSection(IN PCSRSS_PROCESS_DATA CsrProcess OPTIONAL, CsrSrvAttachSharedSection(IN PCSR_PROCESS CsrProcess OPTIONAL,
OUT PCSR_CONNECTION_INFO ConnectInfo) OUT PCSR_CONNECTION_INFO ConnectInfo)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -285,9 +285,9 @@ CsrSrvAttachSharedSection(IN PCSRSS_PROCESS_DATA CsrProcess OPTIONAL,
if (CsrProcess) if (CsrProcess)
{ {
/* Map the section into this process */ /* Map the section into this process */
DPRINT("CSR Process Handle: %p. CSR Process: %p\n", CsrProcess->Process, CsrProcess); DPRINT("CSR Process Handle: %p. CSR Process: %p\n", CsrProcess->ProcessHandle, CsrProcess);
Status = NtMapViewOfSection(CsrSrvSharedSection, Status = NtMapViewOfSection(CsrSrvSharedSection,
CsrProcess->Process, CsrProcess->ProcessHandle,
&CsrSrvSharedSectionBase, &CsrSrvSharedSectionBase,
0, 0,
0, 0,
@ -701,7 +701,7 @@ CsrpHandleConnectionRequest (PPORT_MESSAGE Request,
{ {
NTSTATUS Status; NTSTATUS Status;
HANDLE ServerPort = NULL, ServerThread = NULL; HANDLE ServerPort = NULL, ServerThread = NULL;
PCSRSS_PROCESS_DATA ProcessData = NULL; PCSR_PROCESS ProcessData = NULL;
REMOTE_PORT_VIEW LpcRead; REMOTE_PORT_VIEW LpcRead;
CLIENT_ID ClientId; CLIENT_ID ClientId;
BOOLEAN AllowConnection = FALSE; BOOLEAN AllowConnection = FALSE;
@ -728,7 +728,7 @@ CsrpHandleConnectionRequest (PPORT_MESSAGE Request,
} }
} }
if (ProcessData->Process == NULL) if (ProcessData->ProcessHandle == NULL)
{ {
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
@ -739,11 +739,11 @@ CsrpHandleConnectionRequest (PPORT_MESSAGE Request,
NULL); NULL);
DPRINT1("WARNING: CSR PROCESS WITH NO CSR PROCESS HANDLE???\n"); DPRINT1("WARNING: CSR PROCESS WITH NO CSR PROCESS HANDLE???\n");
ClientId.UniqueThread = 0; ClientId.UniqueThread = 0;
Status = NtOpenProcess(&ProcessData->Process, Status = NtOpenProcess(&ProcessData->ProcessHandle,
PROCESS_ALL_ACCESS, PROCESS_ALL_ACCESS,
&ObjectAttributes, &ObjectAttributes,
&Request->ClientId); &Request->ClientId);
DPRINT1("Status: %lx. Handle: %lx\n", Status, ProcessData->Process); DPRINT1("Status: %lx. Handle: %lx\n", Status, ProcessData->ProcessHandle);
} }
if (ProcessData) if (ProcessData)
@ -773,9 +773,9 @@ CsrpHandleConnectionRequest (PPORT_MESSAGE Request,
return Status; return Status;
} }
ProcessData->CsrSectionViewBase = LpcRead.ViewBase; ProcessData->ClientViewBase = (ULONG_PTR)LpcRead.ViewBase;
ProcessData->CsrSectionViewSize = LpcRead.ViewSize; ProcessData->ClientViewBounds = LpcRead.ViewSize;
ProcessData->ServerCommunicationPort = ServerPort; ProcessData->ClientPort = ServerPort;
if (AllowConnection) Status = NtCompleteConnectPort(ServerPort); if (AllowConnection) Status = NtCompleteConnectPort(ServerPort);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -866,7 +866,7 @@ ClientConnectionThread(HANDLE ServerPort)
BYTE RawRequest[LPC_MAX_DATA_LENGTH]; BYTE RawRequest[LPC_MAX_DATA_LENGTH];
PCSR_API_MESSAGE Request = (PCSR_API_MESSAGE)RawRequest; PCSR_API_MESSAGE Request = (PCSR_API_MESSAGE)RawRequest;
PCSR_API_MESSAGE Reply; PCSR_API_MESSAGE Reply;
PCSRSS_PROCESS_DATA ProcessData; PCSR_PROCESS ProcessData;
PCSR_THREAD ServerThread; PCSR_THREAD ServerThread;
DPRINT("CSR: %s called\n", __FUNCTION__); DPRINT("CSR: %s called\n", __FUNCTION__);
@ -947,7 +947,7 @@ ClientConnectionThread(HANDLE ServerPort)
Request->Header.ClientId.UniqueProcess); Request->Header.ClientId.UniqueProcess);
break; break;
} }
if (ProcessData->Terminated) if (ProcessData->Flags & CsrProcessTerminated)
{ {
DPRINT1("Message %d: process %d already terminated\n", DPRINT1("Message %d: process %d already terminated\n",
Request->Type, Request->Header.ClientId.UniqueProcess); Request->Type, Request->Header.ClientId.UniqueProcess);
@ -963,7 +963,7 @@ ClientConnectionThread(HANDLE ServerPort)
else else
{ {
PCSR_THREAD Thread; PCSR_THREAD Thread;
PCSRSS_PROCESS_DATA Process = NULL; PCSR_PROCESS Process = NULL;
//DPRINT1("locate thread %lx/%lx\n", Request->Header.ClientId.UniqueProcess, Request->Header.ClientId.UniqueThread); //DPRINT1("locate thread %lx/%lx\n", Request->Header.ClientId.UniqueProcess, Request->Header.ClientId.UniqueThread);
Thread = CsrLocateThreadByClientId(&Process, &Request->Header.ClientId); Thread = CsrLocateThreadByClientId(&Process, &Request->Header.ClientId);

8
reactos/subsystems/win32/csrss/csrsrv/init.c
View file

@ -65,7 +65,7 @@ CsrpAddServerProcs(CSRPLUGIN_SERVER_PROCS *Procs)
} }
BOOL BOOL
CallHardError(IN PCSRSS_PROCESS_DATA ProcessData, CallHardError(IN PCSR_PROCESS ProcessData,
IN PHARDERROR_MSG HardErrorMessage) IN PHARDERROR_MSG HardErrorMessage)
{ {
BOOL Ok; BOOL Ok;
@ -83,8 +83,8 @@ CallHardError(IN PCSRSS_PROCESS_DATA ProcessData,
} }
NTSTATUS NTSTATUS
CallProcessInherit(IN PCSRSS_PROCESS_DATA SourceProcessData, CallProcessInherit(IN PCSR_PROCESS SourceProcessData,
IN PCSRSS_PROCESS_DATA TargetProcessData) IN PCSR_PROCESS TargetProcessData)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
unsigned i; unsigned i;
@ -98,7 +98,7 @@ CallProcessInherit(IN PCSRSS_PROCESS_DATA SourceProcessData,
} }
NTSTATUS NTSTATUS
CallProcessDeleted(IN PCSRSS_PROCESS_DATA ProcessData) CallProcessDeleted(IN PCSR_PROCESS ProcessData)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
unsigned i; unsigned i;

22
reactos/subsystems/win32/csrss/csrsrv/procsup.c
View file

@ -23,8 +23,8 @@
/* GLOBALS ********************************************************************/ /* GLOBALS ********************************************************************/
extern RTL_CRITICAL_SECTION ProcessDataLock; extern RTL_CRITICAL_SECTION ProcessDataLock;
extern PCSRSS_PROCESS_DATA ProcessData[256]; extern PCSR_PROCESS ProcessData[256];
PCSRSS_PROCESS_DATA CsrRootProcess; PCSR_PROCESS CsrRootProcess;
SECURITY_QUALITY_OF_SERVICE CsrSecurityQos = SECURITY_QUALITY_OF_SERVICE CsrSecurityQos =
{ {
sizeof(SECURITY_QUALITY_OF_SERVICE), sizeof(SECURITY_QUALITY_OF_SERVICE),
@ -221,12 +221,12 @@ CsrRevertToSelf(VOID)
return NT_SUCCESS(Status); return NT_SUCCESS(Status);
} }
PCSRSS_PROCESS_DATA PCSR_PROCESS
NTAPI NTAPI
FindProcessForShutdown(IN PLUID CallerLuid) FindProcessForShutdown(IN PLUID CallerLuid)
{ {
ULONG Hash; ULONG Hash;
PCSRSS_PROCESS_DATA CsrProcess, ReturnCsrProcess = NULL; PCSR_PROCESS CsrProcess, ReturnCsrProcess = NULL;
NTSTATUS Status; NTSTATUS Status;
ULONG Level = 0; ULONG Level = 0;
LUID ProcessLuid; LUID ProcessLuid;
@ -243,7 +243,7 @@ FindProcessForShutdown(IN PLUID CallerLuid)
if (CsrProcess->Flags & CsrProcessSkipShutdown) goto Next; if (CsrProcess->Flags & CsrProcessSkipShutdown) goto Next;
/* Get the LUID of this Process */ /* Get the LUID of this Process */
Status = CsrGetProcessLuid(CsrProcess->Process, &ProcessLuid); Status = CsrGetProcessLuid(CsrProcess->ProcessHandle, &ProcessLuid);
/* Check if we didn't get access to the LUID */ /* Check if we didn't get access to the LUID */
if (Status == STATUS_ACCESS_DENIED) if (Status == STATUS_ACCESS_DENIED)
@ -303,7 +303,7 @@ CsrEnumProcesses(IN CSRSS_ENUM_PROCESS_PROC EnumProc,
{ {
PVOID* RealContext = (PVOID*)Context; PVOID* RealContext = (PVOID*)Context;
PLUID CallerLuid = RealContext[0]; PLUID CallerLuid = RealContext[0];
PCSRSS_PROCESS_DATA CsrProcess = NULL; PCSR_PROCESS CsrProcess = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL; NTSTATUS Status = STATUS_UNSUCCESSFUL;
BOOLEAN FirstTry; BOOLEAN FirstTry;
ULONG Result = 0; ULONG Result = 0;
@ -349,7 +349,7 @@ CsrEnumProcesses(IN CSRSS_ENUM_PROCESS_PROC EnumProc,
LoopAgain: LoopAgain:
/* Release the lock, make the callback, and acquire it back */ /* Release the lock, make the callback, and acquire it back */
//DPRINT1("Found process: %lx\n", CsrProcess->ProcessId); //DPRINT1("Found process: %lx\n", CsrProcess->ClientId.UniqueProcess);
CsrReleaseProcessLock(); CsrReleaseProcessLock();
Result = (ULONG)EnumProc(CsrProcess, (PVOID)((ULONG_PTR)Context | FirstTry)); Result = (ULONG)EnumProc(CsrProcess, (PVOID)((ULONG_PTR)Context | FirstTry));
CsrAcquireProcessLock(); CsrAcquireProcessLock();
@ -391,10 +391,10 @@ Quickie:
NTSTATUS NTSTATUS
NTAPI NTAPI
CsrLockProcessByClientId(IN HANDLE Pid, CsrLockProcessByClientId(IN HANDLE Pid,
OUT PCSRSS_PROCESS_DATA *CsrProcess OPTIONAL) OUT PCSR_PROCESS *CsrProcess OPTIONAL)
{ {
ULONG Hash; ULONG Hash;
PCSRSS_PROCESS_DATA CurrentProcess = NULL; PCSR_PROCESS CurrentProcess = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL; NTSTATUS Status = STATUS_UNSUCCESSFUL;
/* Acquire the lock */ /* Acquire the lock */
@ -408,7 +408,7 @@ CsrLockProcessByClientId(IN HANDLE Pid,
while (CurrentProcess) while (CurrentProcess)
{ {
/* Check for PID match */ /* Check for PID match */
if (CurrentProcess->ProcessId == Pid) if (CurrentProcess->ClientId.UniqueProcess == Pid)
{ {
/* Get out of here with success */ /* Get out of here with success */
// DPRINT1("Found %p for PID %lx\n", CurrentProcess, Pid); // DPRINT1("Found %p for PID %lx\n", CurrentProcess, Pid);
@ -432,7 +432,7 @@ Found:
NTSTATUS NTSTATUS
NTAPI NTAPI
CsrUnlockProcess(IN PCSRSS_PROCESS_DATA CsrProcess) CsrUnlockProcess(IN PCSR_PROCESS CsrProcess)
{ {
/* Dereference the process */ /* Dereference the process */
//CsrLockedDereferenceProcess(CsrProcess); //CsrLockedDereferenceProcess(CsrProcess);

16
reactos/subsystems/win32/csrss/csrsrv/thredsup.c
View file

@ -26,9 +26,9 @@
/* GLOBALS ********************************************************************/ /* GLOBALS ********************************************************************/
LIST_ENTRY CsrThreadHashTable[256]; LIST_ENTRY CsrThreadHashTable[256];
extern PCSRSS_PROCESS_DATA CsrRootProcess; extern PCSR_PROCESS CsrRootProcess;
extern RTL_CRITICAL_SECTION ProcessDataLock; extern RTL_CRITICAL_SECTION ProcessDataLock;
extern PCSRSS_PROCESS_DATA ProcessData[256]; extern PCSR_PROCESS ProcessData[256];
/* FUNCTIONS ******************************************************************/ /* FUNCTIONS ******************************************************************/
@ -112,7 +112,7 @@ UnProtectHandle(IN HANDLE ObjectHandle)
PCSR_THREAD PCSR_THREAD
NTAPI NTAPI
CsrAllocateThread(IN PCSRSS_PROCESS_DATA CsrProcess) CsrAllocateThread(IN PCSR_PROCESS CsrProcess)
{ {
PCSR_THREAD CsrThread; PCSR_THREAD CsrThread;
@ -133,7 +133,7 @@ CsrAllocateThread(IN PCSRSS_PROCESS_DATA CsrProcess)
PCSR_THREAD PCSR_THREAD
NTAPI NTAPI
CsrLocateThreadByClientId(OUT PCSRSS_PROCESS_DATA *Process OPTIONAL, CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL,
IN PCLIENT_ID ClientId) IN PCLIENT_ID ClientId)
{ {
ULONG i; ULONG i;
@ -174,7 +174,7 @@ CsrLocateThreadByClientId(OUT PCSRSS_PROCESS_DATA *Process OPTIONAL,
PCSR_THREAD PCSR_THREAD
NTAPI NTAPI
CsrLocateThreadInProcess(IN PCSRSS_PROCESS_DATA CsrProcess OPTIONAL, CsrLocateThreadInProcess(IN PCSR_PROCESS CsrProcess OPTIONAL,
IN PCLIENT_ID Cid) IN PCLIENT_ID Cid)
{ {
PLIST_ENTRY ListHead, NextEntry; PLIST_ENTRY ListHead, NextEntry;
@ -208,7 +208,7 @@ CsrLocateThreadInProcess(IN PCSRSS_PROCESS_DATA CsrProcess OPTIONAL,
VOID VOID
NTAPI NTAPI
CsrInsertThread(IN PCSRSS_PROCESS_DATA Process, CsrInsertThread(IN PCSR_PROCESS Process,
IN PCSR_THREAD Thread) IN PCSR_THREAD Thread)
{ {
ULONG i; ULONG i;
@ -295,12 +295,12 @@ CsrThreadRefcountZero(IN PCSR_THREAD CsrThread)
NTSTATUS NTSTATUS
NTAPI NTAPI
CsrCreateThread(IN PCSRSS_PROCESS_DATA CsrProcess, CsrCreateThread(IN PCSR_PROCESS CsrProcess,
IN HANDLE hThread, IN HANDLE hThread,
IN PCLIENT_ID ClientId) IN PCLIENT_ID ClientId)
{ {
PCSR_THREAD CsrThread; PCSR_THREAD CsrThread;
//PCSRSS_PROCESS_DATA CurrentProcess; //PCSR_PROCESS CurrentProcess;
//PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread; //PCSR_THREAD CurrentThread = NtCurrentTeb()->CsrClientThread;
//CLIENT_ID CurrentCid; //CLIENT_ID CurrentCid;
KERNEL_USER_TIMES KernelTimes; KERNEL_USER_TIMES KernelTimes;

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

@ -45,31 +45,47 @@ typedef enum _CSR_PROCESS_FLAGS
CsrProcessIsConsoleApp = 0x800 CsrProcessIsConsoleApp = 0x800
} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS; } CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS;
typedef struct _CSRSS_PROCESS_DATA typedef struct _CSRSS_CON_PROCESS_DATA
{ {
struct tagCSRSS_CONSOLE *Console; HANDLE ConsoleEvent;
struct tagCSRSS_CONSOLE *ParentConsole; struct tagCSRSS_CONSOLE *Console;
BOOL bInheritHandles; struct tagCSRSS_CONSOLE *ParentConsole;
RTL_CRITICAL_SECTION HandleTableLock; BOOL bInheritHandles;
ULONG HandleTableSize; RTL_CRITICAL_SECTION HandleTableLock;
struct _CSRSS_HANDLE *HandleTable; ULONG HandleTableSize;
HANDLE ProcessId; struct _CSRSS_HANDLE *HandleTable;
DWORD ProcessGroup; PCONTROLDISPATCHER CtrlDispatcher;
HANDLE Process; } CSRSS_CON_PROCESS_DATA, *PCSRSS_CON_PROCESS_DATA;
ULONG ShutdownLevel;
ULONG ShutdownFlags; typedef struct _CSR_PROCESS
HANDLE ConsoleEvent; {
PVOID CsrSectionViewBase; CLIENT_ID ClientId;
ULONG CsrSectionViewSize; LIST_ENTRY ListLink;
HANDLE ServerCommunicationPort; LIST_ENTRY ThreadList;
struct _CSRSS_PROCESS_DATA * next; struct _CSR_PROCESS *Parent;
LIST_ENTRY ProcessEntry; // PCSR_NT_SESSION NtSession;
PCONTROLDISPATCHER CtrlDispatcher; ULONG ExpectedVersion;
BOOL Terminated; HANDLE ClientPort;
ULONG Flags; ULONG_PTR ClientViewBase;
ULONG ThreadCount; ULONG_PTR ClientViewBounds;
LIST_ENTRY ThreadList; HANDLE ProcessHandle;
} CSRSS_PROCESS_DATA, *PCSRSS_PROCESS_DATA; ULONG SequenceNumber;
ULONG Flags;
ULONG DebugFlags;
CLIENT_ID DebugCid;
ULONG ReferenceCount;
ULONG ProcessGroupId;
ULONG ProcessGroupSequence;
ULONG fVDM;
ULONG ThreadCount;
ULONG PriorityClass;
ULONG Reserved;
ULONG ShutdownLevel;
ULONG ShutdownFlags;
// PVOID ServerData[ANYSIZE_ARRAY];
struct _CSR_PROCESS* next;
CSRSS_CON_PROCESS_DATA;
} CSR_PROCESS, *PCSR_PROCESS;
typedef struct _CSR_THREAD typedef struct _CSR_THREAD
{ {
@ -77,7 +93,7 @@ typedef struct _CSR_THREAD
LIST_ENTRY Link; LIST_ENTRY Link;
LIST_ENTRY HashLinks; LIST_ENTRY HashLinks;
CLIENT_ID ClientId; CLIENT_ID ClientId;
PCSRSS_PROCESS_DATA Process; PCSR_PROCESS Process;
//struct _CSR_WAIT_BLOCK *WaitBlock; //struct _CSR_WAIT_BLOCK *WaitBlock;
HANDLE ThreadHandle; HANDLE ThreadHandle;
ULONG Flags; ULONG Flags;
@ -85,7 +101,7 @@ typedef struct _CSR_THREAD
ULONG ImpersonationCount; ULONG ImpersonationCount;
} CSR_THREAD, *PCSR_THREAD; } CSR_THREAD, *PCSR_THREAD;
typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSRSS_PROCESS_DATA ProcessData, typedef NTSTATUS (WINAPI *CSRSS_API_PROC)(PCSR_PROCESS ProcessData,
PCSR_API_MESSAGE Request); PCSR_API_MESSAGE Request);
typedef struct _CSRSS_API_DEFINITION typedef struct _CSRSS_API_DEFINITION
@ -106,7 +122,7 @@ typedef struct _CSRSS_LISTEN_DATA
} CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA; } CSRSS_LISTEN_DATA, *PCSRSS_LISTEN_DATA;
#define CSR_API(n) NTSTATUS WINAPI n (\ #define CSR_API(n) NTSTATUS WINAPI n (\
PCSRSS_PROCESS_DATA ProcessData,\ PCSR_PROCESS ProcessData,\
PCSR_API_MESSAGE Request) PCSR_API_MESSAGE Request)
/* init.c */ /* init.c */
@ -123,11 +139,11 @@ CSR_API(CsrSetShutdownParameters);
PCSR_THREAD PCSR_THREAD
NTAPI NTAPI
CsrAllocateThread(IN PCSRSS_PROCESS_DATA CsrProcess); CsrAllocateThread(IN PCSR_PROCESS CsrProcess);
/* 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(PCSR_PROCESS ProcessData,
PCSR_API_MESSAGE Request); PCSR_API_MESSAGE Request);
VOID WINAPI CsrSbApiRequestThread (PVOID PortHandle); VOID WINAPI CsrSbApiRequestThread (PVOID PortHandle);
VOID NTAPI ClientConnectionThread(HANDLE ServerPort); VOID NTAPI ClientConnectionThread(HANDLE ServerPort);
@ -135,19 +151,19 @@ VOID NTAPI ClientConnectionThread(HANDLE ServerPort);
extern HANDLE CsrSbApiPort; extern HANDLE CsrSbApiPort;
/* api/process.c */ /* api/process.c */
typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSRSS_PROCESS_DATA ProcessData, typedef NTSTATUS (WINAPI *CSRSS_ENUM_PROCESS_PROC)(PCSR_PROCESS ProcessData,
PVOID Context); PVOID Context);
VOID WINAPI CsrInitProcessData(VOID); VOID WINAPI CsrInitProcessData(VOID);
PCSRSS_PROCESS_DATA WINAPI CsrGetProcessData(HANDLE ProcessId); PCSR_PROCESS WINAPI CsrGetProcessData(HANDLE ProcessId);
PCSRSS_PROCESS_DATA WINAPI CsrCreateProcessData(HANDLE ProcessId); PCSR_PROCESS WINAPI CsrCreateProcessData(HANDLE ProcessId);
NTSTATUS WINAPI CsrFreeProcessData( HANDLE Pid ); NTSTATUS WINAPI CsrFreeProcessData( HANDLE Pid );
NTSTATUS WINAPI CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context); NTSTATUS WINAPI CsrEnumProcesses(CSRSS_ENUM_PROCESS_PROC EnumProc, PVOID Context);
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags); PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags);
PCSR_THREAD NTAPI CsrLocateThreadInProcess(IN PCSRSS_PROCESS_DATA CsrProcess OPTIONAL, IN PCLIENT_ID Cid); PCSR_THREAD NTAPI CsrLocateThreadInProcess(IN PCSR_PROCESS CsrProcess OPTIONAL, IN PCLIENT_ID Cid);
PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSRSS_PROCESS_DATA *Process OPTIONAL, IN PCLIENT_ID ClientId); PCSR_THREAD NTAPI CsrLocateThreadByClientId(OUT PCSR_PROCESS *Process OPTIONAL, IN PCLIENT_ID ClientId);
NTSTATUS NTAPI CsrLockProcessByClientId(IN HANDLE Pid, OUT PCSRSS_PROCESS_DATA *CsrProcess OPTIONAL); NTSTATUS NTAPI CsrLockProcessByClientId(IN HANDLE Pid, OUT PCSR_PROCESS *CsrProcess OPTIONAL);
NTSTATUS NTAPI CsrCreateThread(IN PCSRSS_PROCESS_DATA CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId); NTSTATUS NTAPI CsrCreateThread(IN PCSR_PROCESS CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId);
NTSTATUS NTAPI CsrUnlockProcess(IN PCSRSS_PROCESS_DATA CsrProcess); NTSTATUS NTAPI CsrUnlockProcess(IN PCSR_PROCESS CsrProcess);
//hack //hack
VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread); VOID NTAPI CsrThreadRefcountZero(IN PCSR_THREAD CsrThread);

8
reactos/subsystems/win32/csrss/include/csrplugin.h
View file

@ -31,13 +31,13 @@ typedef struct tagCSRSS_EXPORTED_FUNCS
typedef BOOL (WINAPI *CSRPLUGIN_INIT_COMPLETE_PROC)(void); typedef BOOL (WINAPI *CSRPLUGIN_INIT_COMPLETE_PROC)(void);
typedef BOOL (WINAPI *CSRPLUGIN_HARDERROR_PROC)(IN PCSRSS_PROCESS_DATA ProcessData, typedef BOOL (WINAPI *CSRPLUGIN_HARDERROR_PROC)(IN PCSR_PROCESS ProcessData,
IN PHARDERROR_MSG HardErrorMessage); IN PHARDERROR_MSG HardErrorMessage);
typedef NTSTATUS (WINAPI *CSRPLUGIN_PROCESS_INHERIT_PROC)(IN PCSRSS_PROCESS_DATA SourceProcessData, typedef NTSTATUS (WINAPI *CSRPLUGIN_PROCESS_INHERIT_PROC)(IN PCSR_PROCESS SourceProcessData,
IN PCSRSS_PROCESS_DATA TargetProcessData); IN PCSR_PROCESS TargetProcessData);
typedef NTSTATUS (WINAPI *CSRPLUGIN_PROCESS_DELETED_PROC)(IN PCSRSS_PROCESS_DATA ProcessData); typedef NTSTATUS (WINAPI *CSRPLUGIN_PROCESS_DELETED_PROC)(IN PCSR_PROCESS ProcessData);
typedef struct tagCSRSS_SERVER_PROCS typedef struct tagCSRSS_SERVER_PROCS
{ {

4
reactos/subsystems/win32/csrss/win32csr/coninput.c
View file

@ -367,13 +367,13 @@ ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode)
(er.Event.KeyEvent.wVirtualKeyCode == 'C')) && (er.Event.KeyEvent.wVirtualKeyCode == 'C')) &&
(er.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED) || KeyState[VK_CONTROL] & 0x80)) (er.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED) || KeyState[VK_CONTROL] & 0x80))
{ {
PCSRSS_PROCESS_DATA current; PCSR_PROCESS current;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
DPRINT1("Console_Api Ctrl-C\n"); DPRINT1("Console_Api Ctrl-C\n");
current_entry = Console->ProcessList.Flink; current_entry = Console->ProcessList.Flink;
while (current_entry != &Console->ProcessList) while (current_entry != &Console->ProcessList)
{ {
current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry); current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ListLink);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
ConioConsoleCtrlEvent((DWORD)CTRL_C_EVENT, current); ConioConsoleCtrlEvent((DWORD)CTRL_C_EVENT, current);
} }

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

@ -141,13 +141,13 @@ typedef struct ConsoleInput_t
#define ConioResizeBuffer(Console, Buff, Size) (Console)->Vtbl->ResizeBuffer(Console, Buff, Size) #define ConioResizeBuffer(Console, Buff, Size) (Console)->Vtbl->ResizeBuffer(Console, Buff, Size)
/* console.c */ /* console.c */
NTSTATUS FASTCALL ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console); NTSTATUS FASTCALL ConioConsoleFromProcessData(PCSR_PROCESS ProcessData, PCSRSS_CONSOLE *Console);
VOID WINAPI ConioDeleteConsole(Object_t *Object); VOID WINAPI ConioDeleteConsole(Object_t *Object);
VOID WINAPI CsrInitConsoleSupport(VOID); VOID WINAPI CsrInitConsoleSupport(VOID);
VOID FASTCALL ConioPause(PCSRSS_CONSOLE Console, UINT Flags); VOID FASTCALL ConioPause(PCSRSS_CONSOLE Console, UINT Flags);
VOID FASTCALL ConioUnpause(PCSRSS_CONSOLE Console, UINT Flags); VOID FASTCALL ConioUnpause(PCSRSS_CONSOLE Console, UINT Flags);
VOID FASTCALL ConioConsoleCtrlEvent(DWORD Event, PCSRSS_PROCESS_DATA ProcessData); VOID FASTCALL ConioConsoleCtrlEvent(DWORD Event, PCSR_PROCESS ProcessData);
VOID FASTCALL ConioConsoleCtrlEventTimeout(DWORD Event, PCSRSS_PROCESS_DATA ProcessData, VOID FASTCALL ConioConsoleCtrlEventTimeout(DWORD Event, PCSR_PROCESS ProcessData,
DWORD Timeout); DWORD Timeout);
CSR_API(CsrAllocConsole); CSR_API(CsrAllocConsole);
CSR_API(CsrFreeConsole); CSR_API(CsrFreeConsole);

2
reactos/subsystems/win32/csrss/win32csr/conoutput.c
View file

@ -389,7 +389,7 @@ CSR_API(CsrWriteConsole)
if (Console->UnpauseEvent) if (Console->UnpauseEvent)
{ {
Status = NtDuplicateObject(GetCurrentProcess(), Console->UnpauseEvent, Status = NtDuplicateObject(GetCurrentProcess(), Console->UnpauseEvent,
ProcessData->Process, &Request->Data.WriteConsoleRequest.UnpauseEvent, ProcessData->ProcessHandle, &Request->Data.WriteConsoleRequest.UnpauseEvent,
SYNCHRONIZE, 0, 0); SYNCHRONIZE, 0, 0);
ConioUnlockScreenBuffer(Buff); ConioUnlockScreenBuffer(Buff);
return NT_SUCCESS(Status) ? STATUS_PENDING : Status; return NT_SUCCESS(Status) ? STATUS_PENDING : Status;

28
reactos/subsystems/win32/csrss/win32csr/console.c
View file

@ -15,7 +15,7 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS FASTCALL NTSTATUS FASTCALL
ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Console) ConioConsoleFromProcessData(PCSR_PROCESS ProcessData, PCSRSS_CONSOLE *Console)
{ {
PCSRSS_CONSOLE ProcessConsole; PCSRSS_CONSOLE ProcessConsole;
@ -38,16 +38,16 @@ ConioConsoleFromProcessData(PCSRSS_PROCESS_DATA ProcessData, PCSRSS_CONSOLE *Con
} }
VOID FASTCALL VOID FASTCALL
ConioConsoleCtrlEventTimeout(DWORD Event, PCSRSS_PROCESS_DATA ProcessData, DWORD Timeout) ConioConsoleCtrlEventTimeout(DWORD Event, PCSR_PROCESS ProcessData, DWORD Timeout)
{ {
HANDLE Thread; HANDLE Thread;
DPRINT("ConioConsoleCtrlEvent Parent ProcessId = %x\n", ProcessData->ProcessId); DPRINT("ConioConsoleCtrlEvent Parent ProcessId = %x\n", ProcessData->ClientId.UniqueProcess);
if (ProcessData->CtrlDispatcher) if (ProcessData->CtrlDispatcher)
{ {
Thread = CreateRemoteThread(ProcessData->Process, NULL, 0, Thread = CreateRemoteThread(ProcessData->ProcessHandle, NULL, 0,
(LPTHREAD_START_ROUTINE) ProcessData->CtrlDispatcher, (LPTHREAD_START_ROUTINE) ProcessData->CtrlDispatcher,
UlongToPtr(Event), 0, NULL); UlongToPtr(Event), 0, NULL);
if (NULL == Thread) if (NULL == Thread)
@ -61,7 +61,7 @@ ConioConsoleCtrlEventTimeout(DWORD Event, PCSRSS_PROCESS_DATA ProcessData, DWORD
} }
VOID FASTCALL VOID FASTCALL
ConioConsoleCtrlEvent(DWORD Event, PCSRSS_PROCESS_DATA ProcessData) ConioConsoleCtrlEvent(DWORD Event, PCSR_PROCESS ProcessData)
{ {
ConioConsoleCtrlEventTimeout(Event, ProcessData, 0); ConioConsoleCtrlEventTimeout(Event, ProcessData, 0);
} }
@ -215,7 +215,7 @@ CSR_API(CsrAllocConsole)
/* initialize list head */ /* initialize list head */
InitializeListHead(&Console->ProcessList); InitializeListHead(&Console->ProcessList);
/* insert process data required for GUI initialization */ /* insert process data required for GUI initialization */
InsertHeadList(&Console->ProcessList, &ProcessData->ProcessEntry); InsertHeadList(&Console->ProcessList, &ProcessData->ListLink);
/* Initialize the Console */ /* Initialize the Console */
Status = CsrInitConsole(Console, Request->Data.AllocConsoleRequest.ShowCmd); Status = CsrInitConsole(Console, Request->Data.AllocConsoleRequest.ShowCmd);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -280,7 +280,7 @@ CSR_API(CsrAllocConsole)
/* Duplicate the Event */ /* Duplicate the Event */
if (!DuplicateHandle(GetCurrentProcess(), if (!DuplicateHandle(GetCurrentProcess(),
ProcessData->Console->ActiveEvent, ProcessData->Console->ActiveEvent,
ProcessData->Process, ProcessData->ProcessHandle,
&ProcessData->ConsoleEvent, &ProcessData->ConsoleEvent,
EVENT_ALL_ACCESS, EVENT_ALL_ACCESS,
FALSE, FALSE,
@ -307,7 +307,7 @@ CSR_API(CsrAllocConsole)
if (!NewConsole) if (!NewConsole)
{ {
/* Insert into the list if it has not been added */ /* Insert into the list if it has not been added */
InsertHeadList(&ProcessData->Console->ProcessList, &ProcessData->ProcessEntry); InsertHeadList(&ProcessData->Console->ProcessList, &ProcessData->ListLink);
} }
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
@ -762,7 +762,7 @@ CSR_API(CsrGetProcessList)
{ {
PDWORD Buffer; PDWORD Buffer;
PCSRSS_CONSOLE Console; PCSRSS_CONSOLE Console;
PCSRSS_PROCESS_DATA current; PCSR_PROCESS current;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
ULONG nItems = 0; ULONG nItems = 0;
NTSTATUS Status; NTSTATUS Status;
@ -786,10 +786,10 @@ CSR_API(CsrGetProcessList)
current_entry != &Console->ProcessList; current_entry != &Console->ProcessList;
current_entry = current_entry->Flink) current_entry = current_entry->Flink)
{ {
current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry); current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ListLink);
if (++nItems <= Request->Data.GetProcessListRequest.nMaxIds) if (++nItems <= Request->Data.GetProcessListRequest.nMaxIds)
{ {
*Buffer++ = HandleToUlong(current->ProcessId); *Buffer++ = HandleToUlong(current->ClientId.UniqueProcess);
} }
} }
@ -802,7 +802,7 @@ CSR_API(CsrGetProcessList)
CSR_API(CsrGenerateCtrlEvent) CSR_API(CsrGenerateCtrlEvent)
{ {
PCSRSS_CONSOLE Console; PCSRSS_CONSOLE Console;
PCSRSS_PROCESS_DATA current; PCSR_PROCESS current;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
DWORD Group; DWORD Group;
NTSTATUS Status; NTSTATUS Status;
@ -822,8 +822,8 @@ CSR_API(CsrGenerateCtrlEvent)
current_entry != &Console->ProcessList; current_entry != &Console->ProcessList;
current_entry = current_entry->Flink) current_entry = current_entry->Flink)
{ {
current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry); current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ListLink);
if (Group == 0 || current->ProcessGroup == Group) if (Group == 0 || current->ProcessGroupId == Group)
{ {
ConioConsoleCtrlEvent(Request->Data.GenerateCtrlEvent.Event, current); ConioConsoleCtrlEvent(Request->Data.GenerateCtrlEvent.Event, current);
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;

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

@ -278,7 +278,7 @@ DllMain(HANDLE hDll,
/* Ensure that a captured buffer is safe to access */ /* Ensure that a captured buffer is safe to access */
BOOL FASTCALL BOOL FASTCALL
Win32CsrValidateBuffer(PCSRSS_PROCESS_DATA ProcessData, PVOID Buffer, Win32CsrValidateBuffer(PCSR_PROCESS ProcessData, PVOID Buffer,
SIZE_T NumElements, SIZE_T ElementSize) SIZE_T NumElements, SIZE_T ElementSize)
{ {
/* Check that the following conditions are true: /* Check that the following conditions are true:
@ -289,14 +289,14 @@ Win32CsrValidateBuffer(PCSRSS_PROCESS_DATA ProcessData, PVOID Buffer,
* instead of division; remember that 2147483648 * 2 = 0.) * instead of division; remember that 2147483648 * 2 = 0.)
* 3. The buffer is DWORD-aligned. * 3. The buffer is DWORD-aligned.
*/ */
ULONG_PTR Offset = (BYTE *)Buffer - (BYTE *)ProcessData->CsrSectionViewBase; ULONG_PTR Offset = (BYTE *)Buffer - (BYTE *)ProcessData->ClientViewBase;
if (Offset >= ProcessData->CsrSectionViewSize if (Offset >= ProcessData->ClientViewBounds
|| NumElements > (ProcessData->CsrSectionViewSize - Offset) / ElementSize || NumElements > (ProcessData->ClientViewBounds - Offset) / ElementSize
|| (Offset & (sizeof(DWORD) - 1)) != 0) || (Offset & (sizeof(DWORD) - 1)) != 0)
{ {
DPRINT1("Invalid buffer %p(%u*%u); section view is %p(%u)\n", DPRINT1("Invalid buffer %p(%u*%u); section view is %p(%u)\n",
Buffer, NumElements, ElementSize, Buffer, NumElements, ElementSize,
ProcessData->CsrSectionViewBase, ProcessData->CsrSectionViewSize); ProcessData->ClientViewBase, ProcessData->ClientViewBounds);
return FALSE; return FALSE;
} }
return TRUE; return TRUE;

42
reactos/subsystems/win32/csrss/win32csr/exitros.c
View file

@ -462,7 +462,7 @@ NotifyTopLevelWindows(PNOTIFY_CONTEXT Context)
} }
static BOOL FASTCALL static BOOL FASTCALL
NotifyAndTerminateProcess(PCSRSS_PROCESS_DATA ProcessData, NotifyAndTerminateProcess(PCSR_PROCESS ProcessData,
PSHUTDOWN_SETTINGS ShutdownSettings, PSHUTDOWN_SETTINGS ShutdownSettings,
UINT Flags) UINT Flags)
{ {
@ -481,7 +481,7 @@ NotifyAndTerminateProcess(PCSRSS_PROCESS_DATA ProcessData,
} }
else else
{ {
Context.ProcessId = (DWORD_PTR) ProcessData->ProcessId; Context.ProcessId = (DWORD_PTR) ProcessData->ClientId.UniqueProcess;
Context.wParam = 0; Context.wParam = 0;
Context.lParam = (0 != (Flags & EWX_INTERNAL_FLAG_LOGOFF) ? Context.lParam = (0 != (Flags & EWX_INTERNAL_FLAG_LOGOFF) ?
ENDSESSION_LOGOFF : 0); ENDSESSION_LOGOFF : 0);
@ -527,10 +527,10 @@ NotifyAndTerminateProcess(PCSRSS_PROCESS_DATA ProcessData,
/* Terminate this process */ /* Terminate this process */
Process = OpenProcess(PROCESS_TERMINATE, FALSE, Process = OpenProcess(PROCESS_TERMINATE, FALSE,
(DWORD_PTR) ProcessData->ProcessId); (DWORD_PTR) ProcessData->ClientId.UniqueProcess);
if (NULL == Process) if (NULL == Process)
{ {
DPRINT1("Unable to open process %d, error %d\n", ProcessData->ProcessId, DPRINT1("Unable to open process %d, error %d\n", ProcessData->ClientId.UniqueProcess,
GetLastError()); GetLastError());
return TRUE; return TRUE;
} }
@ -543,35 +543,35 @@ NotifyAndTerminateProcess(PCSRSS_PROCESS_DATA ProcessData,
typedef struct tagPROCESS_ENUM_CONTEXT typedef struct tagPROCESS_ENUM_CONTEXT
{ {
UINT ProcessCount; UINT ProcessCount;
PCSRSS_PROCESS_DATA *ProcessData; PCSR_PROCESS *ProcessData;
TOKEN_ORIGIN TokenOrigin; TOKEN_ORIGIN TokenOrigin;
DWORD ShellProcess; DWORD ShellProcess;
DWORD CsrssProcess; DWORD CsrssProcess;
} PROCESS_ENUM_CONTEXT, *PPROCESS_ENUM_CONTEXT; } PROCESS_ENUM_CONTEXT, *PPROCESS_ENUM_CONTEXT;
static NTSTATUS WINAPI static NTSTATUS WINAPI
ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data) ExitReactosProcessEnum(PCSR_PROCESS ProcessData, PVOID Data)
{ {
HANDLE Process; HANDLE Process;
HANDLE Token; HANDLE Token;
TOKEN_ORIGIN Origin; TOKEN_ORIGIN Origin;
DWORD ReturnLength; DWORD ReturnLength;
PPROCESS_ENUM_CONTEXT Context = (PPROCESS_ENUM_CONTEXT) Data; PPROCESS_ENUM_CONTEXT Context = (PPROCESS_ENUM_CONTEXT) Data;
PCSRSS_PROCESS_DATA *NewData; PCSR_PROCESS *NewData;
/* Do not kill winlogon or csrss */ /* Do not kill winlogon or csrss */
if ((DWORD_PTR) ProcessData->ProcessId == Context->CsrssProcess || if ((DWORD_PTR) ProcessData->ClientId.UniqueProcess == Context->CsrssProcess ||
ProcessData->ProcessId == LogonProcess) ProcessData->ClientId.UniqueProcess == LogonProcess)
{ {
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/* Get the login session of this process */ /* Get the login session of this process */
Process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, Process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
(DWORD_PTR) ProcessData->ProcessId); (DWORD_PTR) ProcessData->ClientId.UniqueProcess);
if (NULL == Process) if (NULL == Process)
{ {
DPRINT1("Unable to open process %d, error %d\n", ProcessData->ProcessId, DPRINT1("Unable to open process %d, error %d\n", ProcessData->ClientId.UniqueProcess,
GetLastError()); GetLastError());
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -579,7 +579,7 @@ ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
if (! OpenProcessToken(Process, TOKEN_QUERY, &Token)) if (! OpenProcessToken(Process, TOKEN_QUERY, &Token))
{ {
DPRINT1("Unable to open token for process %d, error %d\n", DPRINT1("Unable to open token for process %d, error %d\n",
ProcessData->ProcessId, GetLastError()); ProcessData->ClientId.UniqueProcess, GetLastError());
CloseHandle(Process); CloseHandle(Process);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -589,7 +589,7 @@ ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
sizeof(TOKEN_ORIGIN), &ReturnLength)) sizeof(TOKEN_ORIGIN), &ReturnLength))
{ {
DPRINT1("GetTokenInformation failed for process %d with error %d\n", DPRINT1("GetTokenInformation failed for process %d with error %d\n",
ProcessData->ProcessId, GetLastError()); ProcessData->ClientId.UniqueProcess, GetLastError());
CloseHandle(Token); CloseHandle(Token);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -600,12 +600,12 @@ ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
&(Origin.OriginatingLogonSession))) &(Origin.OriginatingLogonSession)))
{ {
/* Kill the shell process last */ /* Kill the shell process last */
if ((DWORD_PTR) ProcessData->ProcessId == Context->ShellProcess) if ((DWORD_PTR) ProcessData->ClientId.UniqueProcess == Context->ShellProcess)
{ {
ProcessData->ShutdownLevel = 0; ProcessData->ShutdownLevel = 0;
} }
NewData = HeapAlloc(Win32CsrApiHeap, 0, (Context->ProcessCount + 1) NewData = HeapAlloc(Win32CsrApiHeap, 0, (Context->ProcessCount + 1)
* sizeof(PCSRSS_PROCESS_DATA)); * sizeof(PCSR_PROCESS));
if (NULL == NewData) if (NULL == NewData)
{ {
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
@ -613,7 +613,7 @@ ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
if (0 != Context->ProcessCount) if (0 != Context->ProcessCount)
{ {
memcpy(NewData, Context->ProcessData, memcpy(NewData, Context->ProcessData,
Context->ProcessCount * sizeof(PCSRSS_PROCESS_DATA)); Context->ProcessCount * sizeof(PCSR_PROCESS));
HeapFree(Win32CsrApiHeap, 0, Context->ProcessData); HeapFree(Win32CsrApiHeap, 0, Context->ProcessData);
} }
Context->ProcessData = NewData; Context->ProcessData = NewData;
@ -627,8 +627,8 @@ ExitReactosProcessEnum(PCSRSS_PROCESS_DATA ProcessData, PVOID Data)
static int static int
ProcessDataCompare(const void *Elem1, const void *Elem2) ProcessDataCompare(const void *Elem1, const void *Elem2)
{ {
const PCSRSS_PROCESS_DATA *ProcessData1 = (PCSRSS_PROCESS_DATA *) Elem1; const PCSR_PROCESS *ProcessData1 = (PCSR_PROCESS *) Elem1;
const PCSRSS_PROCESS_DATA *ProcessData2 = (PCSRSS_PROCESS_DATA *) Elem2; const PCSR_PROCESS *ProcessData2 = (PCSR_PROCESS *) Elem2;
if ((*ProcessData1)->ShutdownLevel < (*ProcessData2)->ShutdownLevel) if ((*ProcessData1)->ShutdownLevel < (*ProcessData2)->ShutdownLevel)
{ {
@ -638,11 +638,11 @@ ProcessDataCompare(const void *Elem1, const void *Elem2)
{ {
return -1; return -1;
} }
else if ((*ProcessData1)->ProcessId < (*ProcessData2)->ProcessId) else if ((*ProcessData1)->ClientId.UniqueProcess < (*ProcessData2)->ClientId.UniqueProcess)
{ {
return +1; return +1;
} }
else if ((*ProcessData2)->ProcessId < (*ProcessData1)->ProcessId) else if ((*ProcessData2)->ClientId.UniqueProcess < (*ProcessData1)->ClientId.UniqueProcess)
{ {
return -1; return -1;
} }
@ -864,7 +864,7 @@ InternalExitReactos(DWORD ProcessId, DWORD ThreadId, UINT Flags)
return Status; return Status;
} }
qsort(Context.ProcessData, Context.ProcessCount, sizeof(PCSRSS_PROCESS_DATA), qsort(Context.ProcessData, Context.ProcessCount, sizeof(PCSR_PROCESS),
ProcessDataCompare); ProcessDataCompare);
/* Terminate processes, stop if we find one kicking and screaming it doesn't /* Terminate processes, stop if we find one kicking and screaming it doesn't

16
reactos/subsystems/win32/csrss/win32csr/guiconsole.c
View file

@ -393,15 +393,15 @@ static VOID
GuiConsoleWriteUserSettings(PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData) GuiConsoleWriteUserSettings(PCSRSS_CONSOLE Console, PGUI_CONSOLE_DATA GuiData)
{ {
HKEY hKey; HKEY hKey;
PCSRSS_PROCESS_DATA ProcessData; PCSR_PROCESS ProcessData;
if (Console->ProcessList.Flink == &Console->ProcessList) if (Console->ProcessList.Flink == &Console->ProcessList)
{ {
DPRINT("GuiConsoleWriteUserSettings: No Process!!!\n"); DPRINT("GuiConsoleWriteUserSettings: No Process!!!\n");
return; return;
} }
ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSRSS_PROCESS_DATA, ProcessEntry); ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSR_PROCESS, ListLink);
if (!GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ProcessId), &hKey, KEY_READ | KEY_WRITE, TRUE)) if (!GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ClientId.UniqueProcess), &hKey, KEY_READ | KEY_WRITE, TRUE))
{ {
return; return;
} }
@ -690,7 +690,7 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
HFONT OldFont; HFONT OldFont;
TEXTMETRICW Metrics; TEXTMETRICW Metrics;
SIZE CharSize; SIZE CharSize;
PCSRSS_PROCESS_DATA ProcessData; PCSR_PROCESS ProcessData;
HKEY hKey; HKEY hKey;
Console->hWindow = hWnd; Console->hWindow = hWnd;
@ -704,8 +704,8 @@ GuiConsoleHandleNcCreate(HWND hWnd, CREATESTRUCTW *Create)
GuiConsoleUseDefaults(Console, GuiData, Console->ActiveBuffer); GuiConsoleUseDefaults(Console, GuiData, Console->ActiveBuffer);
if (Console->ProcessList.Flink != &Console->ProcessList) if (Console->ProcessList.Flink != &Console->ProcessList)
{ {
ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSRSS_PROCESS_DATA, ProcessEntry); ProcessData = CONTAINING_RECORD(Console->ProcessList.Flink, CSR_PROCESS, ListLink);
if (GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ProcessId), &hKey, KEY_READ, FALSE)) if (GuiConsoleOpenUserSettings(GuiData, PtrToUlong(ProcessData->ClientId.UniqueProcess), &hKey, KEY_READ, FALSE))
{ {
GuiConsoleReadUserSettings(hKey, Console, GuiData, Console->ActiveBuffer); GuiConsoleReadUserSettings(hKey, Console, GuiData, Console->ActiveBuffer);
RegCloseKey(hKey); RegCloseKey(hKey);
@ -1263,7 +1263,7 @@ GuiConsoleHandleClose(HWND hWnd)
PCSRSS_CONSOLE Console; PCSRSS_CONSOLE Console;
PGUI_CONSOLE_DATA GuiData; PGUI_CONSOLE_DATA GuiData;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PCSRSS_PROCESS_DATA current; PCSR_PROCESS current;
GuiConsoleGetDataPointers(hWnd, &Console, &GuiData); GuiConsoleGetDataPointers(hWnd, &Console, &GuiData);
@ -1272,7 +1272,7 @@ GuiConsoleHandleClose(HWND hWnd)
current_entry = Console->ProcessList.Flink; current_entry = Console->ProcessList.Flink;
while (current_entry != &Console->ProcessList) while (current_entry != &Console->ProcessList)
{ {
current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry); current = CONTAINING_RECORD(current_entry, CSR_PROCESS, ListLink);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
/* FIXME: Windows will wait up to 5 seconds for the thread to exit. /* FIXME: Windows will wait up to 5 seconds for the thread to exit.

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

@ -73,7 +73,7 @@ Win32CsrCloseHandleEntry(
NTSTATUS NTSTATUS
FASTCALL FASTCALL
Win32CsrReleaseObject( Win32CsrReleaseObject(
PCSRSS_PROCESS_DATA ProcessData, PCSR_PROCESS ProcessData,
HANDLE Handle) HANDLE Handle)
{ {
ULONG_PTR h = (ULONG_PTR)Handle >> 2; ULONG_PTR h = (ULONG_PTR)Handle >> 2;
@ -93,7 +93,7 @@ Win32CsrReleaseObject(
NTSTATUS NTSTATUS
FASTCALL FASTCALL
Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData, Win32CsrLockObject(PCSR_PROCESS ProcessData,
HANDLE Handle, HANDLE Handle,
Object_t **Object, Object_t **Object,
DWORD Access, DWORD Access,
@ -135,7 +135,7 @@ Win32CsrUnlockObject(Object_t *Object)
NTSTATUS NTSTATUS
WINAPI WINAPI
Win32CsrReleaseConsole( Win32CsrReleaseConsole(
PCSRSS_PROCESS_DATA ProcessData) PCSR_PROCESS ProcessData)
{ {
PCSRSS_CONSOLE Console; PCSRSS_CONSOLE Console;
ULONG i; ULONG i;
@ -154,7 +154,7 @@ Win32CsrReleaseConsole(
{ {
ProcessData->Console = NULL; ProcessData->Console = NULL;
EnterCriticalSection(&Console->Lock); EnterCriticalSection(&Console->Lock);
RemoveEntryList(&ProcessData->ProcessEntry); RemoveEntryList(&ProcessData->ListLink);
LeaveCriticalSection(&Console->Lock); LeaveCriticalSection(&Console->Lock);
if (_InterlockedDecrement(&Console->ReferenceCount) == 0) if (_InterlockedDecrement(&Console->ReferenceCount) == 0)
ConioDeleteConsole(&Console->Header); ConioDeleteConsole(&Console->Header);
@ -170,7 +170,7 @@ Win32CsrReleaseConsole(
NTSTATUS NTSTATUS
FASTCALL FASTCALL
Win32CsrInsertObject( Win32CsrInsertObject(
PCSRSS_PROCESS_DATA ProcessData, PCSR_PROCESS ProcessData,
PHANDLE Handle, PHANDLE Handle,
Object_t *Object, Object_t *Object,
DWORD Access, DWORD Access,
@ -219,8 +219,8 @@ Win32CsrInsertObject(
NTSTATUS NTSTATUS
WINAPI WINAPI
Win32CsrDuplicateHandleTable( Win32CsrDuplicateHandleTable(
PCSRSS_PROCESS_DATA SourceProcessData, PCSR_PROCESS SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData) PCSR_PROCESS TargetProcessData)
{ {
ULONG i; ULONG i;

2
reactos/subsystems/win32/csrss/win32csr/harderror.c
View file

@ -503,7 +503,7 @@ CsrpMessageBox(
BOOL BOOL
WINAPI WINAPI
Win32CsrHardError( Win32CsrHardError(
IN PCSRSS_PROCESS_DATA ProcessData, IN PCSR_PROCESS ProcessData,
IN PHARDERROR_MSG Message) IN PHARDERROR_MSG Message)
{ {
ULONG_PTR Parameters[MAXIMUM_HARDERROR_PARAMETERS]; ULONG_PTR Parameters[MAXIMUM_HARDERROR_PARAMETERS];

2
reactos/subsystems/win32/csrss/win32csr/w32csr.h
View file

@ -26,7 +26,7 @@
BOOL BOOL
WINAPI WINAPI
Win32CsrHardError( Win32CsrHardError(
IN PCSRSS_PROCESS_DATA ProcessData, IN PCSR_PROCESS ProcessData,
IN PHARDERROR_MSG Message); IN PHARDERROR_MSG Message);
/* EOF */ /* EOF */

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

@ -40,30 +40,30 @@ typedef struct tagCSRSS_OBJECT_DEFINITION
} CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION; } CSRSS_OBJECT_DEFINITION, *PCSRSS_OBJECT_DEFINITION;
/* handle.c */ /* handle.c */
NTSTATUS FASTCALL Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS FASTCALL Win32CsrInsertObject(PCSR_PROCESS ProcessData,
PHANDLE Handle, PHANDLE Handle,
Object_t *Object, Object_t *Object,
DWORD Access, DWORD Access,
BOOL Inheritable, BOOL Inheritable,
DWORD ShareMode); DWORD ShareMode);
NTSTATUS FASTCALL Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS FASTCALL Win32CsrLockObject(PCSR_PROCESS ProcessData,
HANDLE Handle, HANDLE Handle,
Object_t **Object, Object_t **Object,
DWORD Access, DWORD Access,
long Type); long Type);
VOID FASTCALL Win32CsrUnlockObject(Object_t *Object); VOID FASTCALL Win32CsrUnlockObject(Object_t *Object);
NTSTATUS FASTCALL Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS FASTCALL Win32CsrReleaseObject(PCSR_PROCESS ProcessData,
HANDLE Object); HANDLE Object);
NTSTATUS WINAPI Win32CsrReleaseConsole(PCSRSS_PROCESS_DATA ProcessData); NTSTATUS WINAPI Win32CsrReleaseConsole(PCSR_PROCESS ProcessData);
NTSTATUS WINAPI Win32CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData, NTSTATUS WINAPI Win32CsrDuplicateHandleTable(PCSR_PROCESS SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData); PCSR_PROCESS TargetProcessData);
CSR_API(CsrGetHandle); CSR_API(CsrGetHandle);
CSR_API(CsrCloseHandle); CSR_API(CsrCloseHandle);
CSR_API(CsrVerifyHandle); CSR_API(CsrVerifyHandle);
CSR_API(CsrDuplicateHandle); CSR_API(CsrDuplicateHandle);
CSR_API(CsrGetInputWaitHandle); CSR_API(CsrGetInputWaitHandle);
BOOL FASTCALL Win32CsrValidateBuffer(PCSRSS_PROCESS_DATA ProcessData, BOOL FASTCALL Win32CsrValidateBuffer(PCSR_PROCESS ProcessData,
PVOID Buffer, PVOID Buffer,
SIZE_T NumElements, SIZE_T NumElements,
SIZE_T ElementSize); SIZE_T ElementSize);