Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-10 20:27:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix formatting, no code change

Browse source 
svn path=/trunk/; revision=39655
This commit is contained in:
Timo Kreuzer 2009-02-18 03:07:20 +00:00
parent 8d0e6f5f04
commit beab8fa0dc
1 changed files with 149 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

267
reactos/subsystems/win32/csrss/api/handle.c
View file

@ -19,159 +19,185 @@
static unsigned ObjectDefinitionsCount = 0; static unsigned ObjectDefinitionsCount = 0;
static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL; static PCSRSS_OBJECT_DEFINITION ObjectDefinitions = NULL;
static BOOL static
BOOL
CsrIsConsoleHandle(HANDLE Handle) CsrIsConsoleHandle(HANDLE Handle)
{ {
return ((ULONG)Handle & 0x10000003) == 0x3; return ((ULONG)Handle & 0x10000003) == 0x3;
} }
NTSTATUS FASTCALL NTSTATUS
CsrRegisterObjectDefinitions(PCSRSS_OBJECT_DEFINITION NewDefinitions) FASTCALL
CsrRegisterObjectDefinitions(
PCSRSS_OBJECT_DEFINITION NewDefinitions)
{ {
unsigned NewCount; unsigned NewCount;
PCSRSS_OBJECT_DEFINITION Scan; PCSRSS_OBJECT_DEFINITION Scan;
PCSRSS_OBJECT_DEFINITION New; PCSRSS_OBJECT_DEFINITION New;
NewCount = 0; NewCount = 0;
for (Scan = NewDefinitions; 0 != Scan->Type; Scan++) for (Scan = NewDefinitions; 0 != Scan->Type; Scan++)
{ {
NewCount++; NewCount++;
} }
New = RtlAllocateHeap(CsrssApiHeap, 0, New = RtlAllocateHeap(CsrssApiHeap,
(ObjectDefinitionsCount + NewCount) 0,
* sizeof(CSRSS_OBJECT_DEFINITION)); (ObjectDefinitionsCount + NewCount)
if (NULL == New) * sizeof(CSRSS_OBJECT_DEFINITION));
if (NULL == New)
{ {
DPRINT1("Unable to allocate memory\n"); DPRINT1("Unable to allocate memory\n");
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
if (0 != ObjectDefinitionsCount)
{
RtlCopyMemory(New, ObjectDefinitions,
ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
RtlFreeHeap(CsrssApiHeap, 0, ObjectDefinitions);
}
RtlCopyMemory(New + ObjectDefinitionsCount, NewDefinitions,
NewCount * sizeof(CSRSS_OBJECT_DEFINITION));
ObjectDefinitions = New;
ObjectDefinitionsCount += NewCount;
return STATUS_SUCCESS; if (0 != ObjectDefinitionsCount)
{
RtlCopyMemory(New,
ObjectDefinitions,
ObjectDefinitionsCount * sizeof(CSRSS_OBJECT_DEFINITION));
RtlFreeHeap(CsrssApiHeap, 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, HANDLE Handle, Object_t **Object, DWORD Access ) NTSTATUS
WINAPI
CsrGetObject(
PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
Object_t **Object,
DWORD Access )
{ {
ULONG h = (ULONG)Handle >> 2; ULONG h = (ULONG)Handle >> 2;
DPRINT("CsrGetObject, Object: %x, %x, %x\n", Object, Handle, ProcessData ? ProcessData->HandleTableSize : 0);
RtlEnterCriticalSection(&ProcessData->HandleTableLock); DPRINT("CsrGetObject, Object: %x, %x, %x\n",
if (!CsrIsConsoleHandle(Handle) || h >= ProcessData->HandleTableSize Object, Handle, ProcessData ? ProcessData->HandleTableSize : 0);
|| (*Object = ProcessData->HandleTable[h].Object) == NULL
|| ~ProcessData->HandleTable[h].Access & Access) RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (!CsrIsConsoleHandle(Handle) || h >= ProcessData->HandleTableSize
|| (*Object = ProcessData->HandleTable[h].Object) == NULL
|| ~ProcessData->HandleTable[h].Access & Access)
{ {
DPRINT1("CsrGetObject returning invalid handle (%x)\n", Handle); DPRINT1("CsrGetObject returning invalid handle (%x)\n", Handle);
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_HANDLE; return STATUS_INVALID_HANDLE;
} }
_InterlockedIncrement(&(*Object)->ReferenceCount); _InterlockedIncrement(&(*Object)->ReferenceCount);
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
// DbgPrint( "CsrGetObject returning\n" ); // DbgPrint( "CsrGetObject returning\n" );
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS WINAPI NTSTATUS
CsrReleaseObjectByPointer(Object_t *Object) WINAPI
CsrReleaseObjectByPointer(
Object_t *Object)
{ {
unsigned DefIndex; unsigned DefIndex;
/* dec ref count */ /* dec ref count */
if (_InterlockedDecrement(&Object->ReferenceCount) == 0) if (_InterlockedDecrement(&Object->ReferenceCount) == 0)
{ {
for (DefIndex = 0; DefIndex < ObjectDefinitionsCount; DefIndex++) for (DefIndex = 0; DefIndex < ObjectDefinitionsCount; DefIndex++)
{ {
if (Object->Type == ObjectDefinitions[DefIndex].Type) if (Object->Type == ObjectDefinitions[DefIndex].Type)
{ {
(ObjectDefinitions[DefIndex].CsrCleanupObjectProc)(Object); (ObjectDefinitions[DefIndex].CsrCleanupObjectProc)(Object);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
} }
DPRINT1("CSR: Error: releasing unknown object type 0x%x", Object->Type); DPRINT1("CSR: Error: releasing unknown object type 0x%x", Object->Type);
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NTSTATUS WINAPI NTSTATUS
CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData, WINAPI
HANDLE Handle) CsrReleaseObject(
PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
{ {
ULONG h = (ULONG)Handle >> 2; ULONG h = (ULONG)Handle >> 2;
Object_t *Object; Object_t *Object;
RtlEnterCriticalSection(&ProcessData->HandleTableLock); RtlEnterCriticalSection(&ProcessData->HandleTableLock);
if (h >= ProcessData->HandleTableSize if (h >= ProcessData->HandleTableSize
|| (Object = ProcessData->HandleTable[h].Object) == NULL) || (Object = ProcessData->HandleTable[h].Object) == NULL)
{ {
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return STATUS_INVALID_HANDLE; return STATUS_INVALID_HANDLE;
} }
ProcessData->HandleTable[h].Object = NULL; ProcessData->HandleTable[h].Object = NULL;
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return CsrReleaseObjectByPointer(Object); return CsrReleaseObjectByPointer(Object);
} }
NTSTATUS WINAPI CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS
PHANDLE Handle, WINAPI
Object_t *Object, CsrInsertObject(
DWORD Access, PCSRSS_PROCESS_DATA ProcessData,
BOOL Inheritable) PHANDLE Handle,
Object_t *Object,
DWORD Access,
BOOL Inheritable)
{ {
ULONG i; ULONG i;
PVOID* Block; PVOID* Block;
RtlEnterCriticalSection(&ProcessData->HandleTableLock); RtlEnterCriticalSection(&ProcessData->HandleTableLock);
for (i = 0; i < ProcessData->HandleTableSize; i++) for (i = 0; i < ProcessData->HandleTableSize; i++)
{ {
if (ProcessData->HandleTable[i].Object == NULL) if (ProcessData->HandleTable[i].Object == NULL)
{ {
break; break;
} }
} }
if (i >= ProcessData->HandleTableSize) if (i >= ProcessData->HandleTableSize)
{ {
Block = RtlAllocateHeap(CsrssApiHeap, Block = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY, HEAP_ZERO_MEMORY,
(ProcessData->HandleTableSize + 64) * sizeof(CSRSS_HANDLE)); (ProcessData->HandleTableSize + 64) * sizeof(CSRSS_HANDLE));
if (Block == NULL) if (Block == NULL)
{ {
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
RtlCopyMemory(Block, RtlCopyMemory(Block,
ProcessData->HandleTable, ProcessData->HandleTable,
ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE)); ProcessData->HandleTableSize * sizeof(CSRSS_HANDLE));
Block = _InterlockedExchangePointer((volatile void*)&ProcessData->HandleTable, Block); Block = _InterlockedExchangePointer((volatile void*)&ProcessData->HandleTable, Block);
RtlFreeHeap( CsrssApiHeap, 0, Block ); RtlFreeHeap( CsrssApiHeap, 0, Block );
ProcessData->HandleTableSize += 64; ProcessData->HandleTableSize += 64;
} }
ProcessData->HandleTable[i].Object = Object; ProcessData->HandleTable[i].Object = Object;
ProcessData->HandleTable[i].Access = Access; ProcessData->HandleTable[i].Access = Access;
ProcessData->HandleTable[i].Inheritable = Inheritable; ProcessData->HandleTable[i].Inheritable = Inheritable;
*Handle = (HANDLE)((i << 2) | 0x3); *Handle = (HANDLE)((i << 2) | 0x3);
_InterlockedIncrement( &Object->ReferenceCount ); _InterlockedIncrement( &Object->ReferenceCount );
RtlLeaveCriticalSection(&ProcessData->HandleTableLock); RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData, NTSTATUS
PCSRSS_PROCESS_DATA TargetProcessData) WINAPI
CsrDuplicateHandleTable(
PCSRSS_PROCESS_DATA SourceProcessData,
PCSRSS_PROCESS_DATA TargetProcessData)
{ {
ULONG i; ULONG i;
@ -185,38 +211,43 @@ NTSTATUS WINAPI CsrDuplicateHandleTable(PCSRSS_PROCESS_DATA SourceProcessData,
/* we are called from CreateProcessData, it isn't necessary to lock the target process data */ /* we are called from CreateProcessData, it isn't necessary to lock the target process data */
TargetProcessData->HandleTable = RtlAllocateHeap(CsrssApiHeap, TargetProcessData->HandleTable = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY, HEAP_ZERO_MEMORY,
SourceProcessData->HandleTableSize * sizeof(CSRSS_HANDLE)); SourceProcessData->HandleTableSize
* sizeof(CSRSS_HANDLE));
if (TargetProcessData->HandleTable == NULL) if (TargetProcessData->HandleTable == NULL)
{ {
RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock); RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock);
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
TargetProcessData->HandleTableSize = SourceProcessData->HandleTableSize; TargetProcessData->HandleTableSize = SourceProcessData->HandleTableSize;
for (i = 0; i < SourceProcessData->HandleTableSize; i++) for (i = 0; i < SourceProcessData->HandleTableSize; i++)
{ {
if (SourceProcessData->HandleTable[i].Object != NULL if (SourceProcessData->HandleTable[i].Object != NULL &&
&& SourceProcessData->HandleTable[i].Inheritable) SourceProcessData->HandleTable[i].Inheritable)
{ {
TargetProcessData->HandleTable[i] = SourceProcessData->HandleTable[i]; TargetProcessData->HandleTable[i] = SourceProcessData->HandleTable[i];
_InterlockedIncrement( &SourceProcessData->HandleTable[i].Object->ReferenceCount ); _InterlockedIncrement( &SourceProcessData->HandleTable[i].Object->ReferenceCount );
} }
} }
RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock); RtlLeaveCriticalSection(&SourceProcessData->HandleTableLock);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
NTSTATUS WINAPI CsrVerifyObject( PCSRSS_PROCESS_DATA ProcessData, HANDLE Handle ) NTSTATUS
WINAPI
CsrVerifyObject(
PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle)
{ {
ULONG h = (ULONG)Handle >> 2; ULONG h = (ULONG)Handle >> 2;
if (h >= ProcessData->HandleTableSize if (h >= ProcessData->HandleTableSize ||
|| ProcessData->HandleTable[h].Object == NULL) ProcessData->HandleTable[h].Object == NULL)
{ {
return STATUS_INVALID_HANDLE; return STATUS_INVALID_HANDLE;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/* EOF */ /* EOF */