-/*
+/* $Id: object.c,v 1.46 2002/03/05 00:19:28 ekohl Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ob/object.c
* PURPOSE: Implements generic object managment functions
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* 10/06/98: Created
*/
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <roscfg.h>
#include <internal/ob.h>
-#include <wstring.h>
+#include <internal/ps.h>
+#include <internal/id.h>
+#include <internal/ke.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ************************************************************/
-NTSTATUS STDCALL NtSetInformationObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- IN PVOID ObjectInformation,
- IN ULONG Length)
+PVOID HEADER_TO_BODY(POBJECT_HEADER obj)
{
- return(ZwSetInformationObject(ObjectHandle,
- ObjectInformationClass,
- ObjectInformation,
- Length));
+ return(((void *)obj)+sizeof(OBJECT_HEADER)-sizeof(COMMON_BODY_HEADER));
}
-NTSTATUS STDCALL ZwSetInformationObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- IN PVOID ObjectInformation,
- IN ULONG Length)
+POBJECT_HEADER BODY_TO_HEADER(PVOID body)
{
- UNIMPLEMENTED;
+ PCOMMON_BODY_HEADER chdr = (PCOMMON_BODY_HEADER)body;
+ return(CONTAINING_RECORD((&(chdr->Type)),OBJECT_HEADER,Type));
}
-NTSTATUS STDCALL NtQueryObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- OUT PVOID ObjectInformation,
- IN ULONG Length,
- OUT PULONG ResultLength)
-{
- return(ZwQueryObject(ObjectHandle,
- ObjectInformationClass,
- ObjectInformation,
- Length,
- ResultLength));
-}
-NTSTATUS STDCALL ZwQueryObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- OUT PVOID ObjectInformation,
- IN ULONG Length,
- OUT PULONG ResultLength)
+/**********************************************************************
+ * NAME PRIVATE
+ * ObInitializeObject
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
+ */
+VOID ObInitializeObject(POBJECT_HEADER ObjectHeader,
+ PHANDLE Handle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_TYPE Type,
+ POBJECT_ATTRIBUTES ObjectAttributes)
{
- UNIMPLEMENTED
+ ObjectHeader->HandleCount = 0;
+ ObjectHeader->RefCount = 1;
+ ObjectHeader->ObjectType = Type;
+ if (ObjectAttributes != NULL &&
+ ObjectAttributes->Attributes & OBJ_PERMANENT)
+ {
+ ObjectHeader->Permanent = TRUE;
+ }
+ else
+ {
+ ObjectHeader->Permanent = FALSE;
+ }
+ RtlInitUnicodeString(&(ObjectHeader->Name),NULL);
+ if (Handle != NULL)
+ {
+ ObCreateHandle(PsGetCurrentProcess(),
+ HEADER_TO_BODY(ObjectHeader),
+ DesiredAccess,
+ FALSE,
+ Handle);
+ }
}
-NTSTATUS NtMakeTemporaryObject(HANDLE Handle)
-{
- return(ZwMakeTemporaryObject(Handle));
-}
-NTSTATUS ZwMakeTemporaryObject(HANDLE Handle)
+/**********************************************************************
+ * NAME PRIVATE
+ * ObFindObject@16
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ * ObjectAttributes
+ *
+ * ReturnedObject
+ *
+ * RemainigPath
+ * Pointer to a unicode string that will contain the
+ * remaining path if the function returns successfully.
+ * The caller must free the buffer after use by calling
+ * RtlFreeUnicodeString ().
+ *
+ * ObjectType
+ * Optional pointer to an object type. This is used to
+ * descide if a symbolic link object will be parsed or not.
+ *
+ * RETURN VALUE
+ */
+NTSTATUS ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
+ PVOID* ReturnedObject,
+ PUNICODE_STRING RemainingPath,
+ POBJECT_TYPE ObjectType)
{
- PVOID Object;
- NTSTATUS Status;
- POBJECT_HEADER ObjectHeader;
+ PVOID NextObject;
+ PVOID CurrentObject;
+ PVOID RootObject;
+ POBJECT_HEADER CurrentHeader;
+ NTSTATUS Status;
+ PWSTR Path;
+ PWSTR current;
+ UNICODE_STRING PathString;
- Status = ObReferenceObjectByHandle(Handle,
- 0,
- NULL,
- KernelMode,
- &Object,
- NULL);
- if (Status != STATUS_SUCCESS)
- {
- return(Status);
- }
+ DPRINT("ObFindObject(ObjectAttributes %x, ReturnedObject %x, "
+ "RemainingPath %x)\n",ObjectAttributes,ReturnedObject,RemainingPath);
+ DPRINT("ObjectAttributes->ObjectName %wZ\n",
+ ObjectAttributes->ObjectName);
- ObjectHeader = BODY_TO_HEADER(Object);
- ObjectHeader->Permanent = FALSE;
-
- ObDereferenceObject(Object);
-
- return(STATUS_SUCCESS);
-}
+ RtlInitUnicodeString (RemainingPath, NULL);
-PVOID ObGenericCreateObject(PHANDLE Handle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes,
- POBJECT_TYPE Type)
-{
- POBJECT_HEADER hdr = NULL;
- UNICODE_STRING ObjectName;
- PWSTR path;
- PWSTR name;
- PWSTR Ignored;
-
- DPRINT("ObGenericCreateObject(Handle %x, DesiredAccess %x,"
- "ObjectAttributes %x, Type %x)\n",Handle,DesiredAccess,
- ObjectAttributes,Type);
-
- /*
- * Allocate the object body and header
- */
- hdr=(POBJECT_HEADER)ExAllocatePool(NonPagedPool,OBJECT_ALLOC_SIZE(Type));
- if (hdr==NULL)
+ if (ObjectAttributes->RootDirectory == NULL)
{
- return(NULL);
+ ObReferenceObjectByPointer(NameSpaceRoot,
+ DIRECTORY_TRAVERSE,
+ NULL,
+ UserMode);
+ CurrentObject = NameSpaceRoot;
}
-
- /*
- * If unnamed then initalize
- */
- if (ObjectAttributes==NULL)
+ else
{
- ObInitializeObjectHeader(Type,NULL,hdr);
- if (Handle != NULL)
+ Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory,
+ DIRECTORY_TRAVERSE,
+ NULL,
+ UserMode,
+ &CurrentObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- *Handle = ObInsertHandle(KeGetCurrentProcess(),
- HEADER_TO_BODY(hdr),
- DesiredAccess,
- FALSE);
+ return(Status);
}
- return(HEADER_TO_BODY(hdr));
}
- /*
- * Copy the object name into a buffer
- */
- DPRINT("ObjectAttributes->ObjectName %x\n",ObjectAttributes->ObjectName);
- DPRINT("ObjectAttributes->ObjectName->Length %d\n",
- ObjectAttributes->ObjectName->Length);
- ObjectName.MaximumLength = ObjectAttributes->ObjectName->Length;
- ObjectName.Buffer = ExAllocatePool(NonPagedPool,
- ((ObjectAttributes->ObjectName->Length+1)*2));
- if (ObjectName.Buffer==NULL)
+ Path = ObjectAttributes->ObjectName->Buffer;
+
+ if (Path[0] == 0)
{
- return(NULL);
+ *ReturnedObject = CurrentObject;
+ return(STATUS_SUCCESS);
}
- RtlCopyUnicodeString(&ObjectName,ObjectAttributes->ObjectName);
- /*
- * Seperate the name into a path and name
- */
- name = wcsrchr(ObjectName.Buffer,'\\');
- if (name==NULL)
+ if ((ObjectAttributes->RootDirectory == NULL) && (Path[0] != '\\'))
{
- name=ObjectName.Buffer;
- path=NULL;
+ ObDereferenceObject(CurrentObject);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ if (Path)
+ {
+ RtlCreateUnicodeString (&PathString, Path);
+ current = PathString.Buffer;
}
else
{
- path=ObjectName.Buffer;
- *name=0;
- name=name+1;
+ RtlInitUnicodeString (&PathString, NULL);
+ current = NULL;
}
-
- ObLookupObject(ObjectAttributes->RootDirectory,path,
- &hdr->Parent,&Ignored);
-
- /*
- * Initialize the object header
- */
- ObInitializeObjectHeader(Type,name,hdr);
- ObCreateEntry(hdr->Parent,hdr);
-
- DPRINT("Handle %x\n",Handle);
- if (Handle != NULL)
+
+ RootObject = CurrentObject;
+
+ while (TRUE)
{
- *Handle = ObInsertHandle(KeGetCurrentProcess(),
- HEADER_TO_BODY(hdr),
- DesiredAccess,
- FALSE);
+ DPRINT("current %S\n",current);
+ CurrentHeader = BODY_TO_HEADER(CurrentObject);
+
+ DPRINT("Current ObjectType %wZ\n",
+ &CurrentHeader->ObjectType->TypeName);
+
+ if (CurrentHeader->ObjectType->Parse == NULL)
+ {
+ DPRINT("Current object can't parse\n");
+ break;
+ }
+ Status = CurrentHeader->ObjectType->Parse(CurrentObject,
+ &NextObject,
+ &PathString,
+ ¤t,
+ ObjectType,
+ ObjectAttributes->Attributes);
+ if (Status == STATUS_REPARSE)
+ {
+ /* reparse the object path */
+ NextObject = RootObject;
+ current = PathString.Buffer;
+
+ ObReferenceObjectByPointer(NextObject,
+ DIRECTORY_TRAVERSE,
+ NULL,
+ UserMode);
+ }
+
+ if (NextObject == NULL)
+ {
+ break;
+ }
+ ObDereferenceObject(CurrentObject);
+ CurrentObject = NextObject;
}
- return(HEADER_TO_BODY(hdr));
+ if (current)
+ RtlCreateUnicodeString (RemainingPath, current);
+ RtlFreeUnicodeString (&PathString);
+ *ReturnedObject = CurrentObject;
+
+ return(STATUS_SUCCESS);
}
-VOID ObInitializeObjectHeader(POBJECT_TYPE Type, PWSTR name,
- POBJECT_HEADER ObjectHeader)
-/*
- * FUNCTION: Creates a new object
- * ARGUMENT:
- * id = Identifier for the type of object
- * obj = Pointer to the header of the object
+
+/**********************************************************************
+ * NAME EXPORTED
+ * ObCreateObject@36
+ *
+ * DESCRIPTION
+ *
+ * ARGUMENTS
+ *
+ * RETURN VALUE
*/
+NTSTATUS STDCALL
+ObCreateObject(OUT PHANDLE Handle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN POBJECT_TYPE Type,
+ OUT PVOID *Object)
{
- PWSTR temp_name;
-
- DPRINT("ObInitializeObjectHeader(id %x name %w obj %x)\n",Type,
- name,ObjectHeader);
-
- ObjectHeader->HandleCount = 0;
- ObjectHeader->RefCount = 0;
- ObjectHeader->ObjectType = Type;
- ObjectHeader->Permanent = FALSE;
- if (name==NULL)
- {
- ObjectHeader->Name.Length=0;
- ObjectHeader->Name.Buffer=NULL;
- }
- else
- {
- ObjectHeader->Name.MaximumLength = wstrlen(name);
- ObjectHeader->Name.Buffer = ExAllocatePool(NonPagedPool,
- (ObjectHeader->Name.MaximumLength+1)*2);
- RtlInitUnicodeString(&ObjectHeader->Name,name);
- }
+ PVOID Parent = NULL;
+ UNICODE_STRING RemainingPath;
+ POBJECT_HEADER Header;
+ POBJECT_HEADER ParentHeader = NULL;
+ NTSTATUS Status;
+ BOOLEAN ObjectAttached = FALSE;
+
+ assert_irql(APC_LEVEL);
+
+ DPRINT("ObCreateObject(Handle %x, ObjectAttributes %x, Type %x)\n",
+ Handle, ObjectAttributes, Type);
+ if (ObjectAttributes != NULL &&
+ ObjectAttributes->ObjectName != NULL)
+ {
+ DPRINT("ObjectAttributes->ObjectName->Buffer %S\n",
+ ObjectAttributes->ObjectName->Buffer);
+ }
+
+ if (ObjectAttributes != NULL &&
+ ObjectAttributes->ObjectName != NULL)
+ {
+ Status = ObFindObject(ObjectAttributes,
+ &Parent,
+ &RemainingPath,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("ObFindObject() failed! (Status 0x%x)\n", Status);
+ return(Status);
+ }
+ }
+ else
+ {
+ RtlInitUnicodeString(&RemainingPath, NULL);
+ }
+
+ RtlMapGenericMask(&DesiredAccess,
+ Type->Mapping);
+
+ Header = (POBJECT_HEADER)ExAllocatePoolWithTag(NonPagedPool,
+ OBJECT_ALLOC_SIZE(Type),
+ Type->Tag);
+ ObInitializeObject(Header,
+ Handle,
+ DesiredAccess,
+ Type,
+ ObjectAttributes);
+
+ if (Parent != NULL)
+ {
+ ParentHeader = BODY_TO_HEADER(Parent);
+ }
+
+ if (ParentHeader != NULL &&
+ ParentHeader->ObjectType == ObDirectoryType &&
+ RemainingPath.Buffer != NULL)
+ {
+ ObpAddEntryDirectory(Parent,
+ Header,
+ RemainingPath.Buffer+1);
+ ObjectAttached = TRUE;
+ }
+
+ if ((Header->ObjectType != NULL) &&
+ (Header->ObjectType->Create != NULL))
+ {
+ DPRINT("Calling %x\n", Header->ObjectType->Create);
+ Status = Header->ObjectType->Create(HEADER_TO_BODY(Header),
+ Parent,
+ RemainingPath.Buffer,
+ ObjectAttributes);
+ if (!NT_SUCCESS(Status))
+ {
+ if (ObjectAttached == TRUE)
+ {
+ ObpRemoveEntryDirectory(Header);
+ }
+ if (Parent)
+ {
+ ObDereferenceObject(Parent);
+ }
+ RtlFreeUnicodeString(&Header->Name);
+ RtlFreeUnicodeString(&RemainingPath);
+ ExFreePool(Header);
+ return(Status);
+ }
+ }
+ RtlFreeUnicodeString( &RemainingPath );
+
+ *Object = HEADER_TO_BODY(Header);
+
+ return(STATUS_SUCCESS);
}
-NTSTATUS ObReferenceObjectByPointer(PVOID ObjectBody,
- ACCESS_MASK DesiredAccess,
- POBJECT_TYPE ObjectType,
- KPROCESSOR_MODE AccessMode)
+NTSTATUS STDCALL
+ObReferenceObjectByPointer(IN PVOID Object,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_TYPE ObjectType,
+ IN KPROCESSOR_MODE AccessMode)
/*
* FUNCTION: Increments the pointer reference count for a given object
* ARGUMENTS:
* RETURNS: Status
*/
{
- POBJECT_HEADER Object;
+ POBJECT_HEADER Header;
- DPRINT("ObReferenceObjectByPointer(%x)\n",ObjectBody);
+// DPRINT("ObReferenceObjectByPointer(Object %x, ObjectType %x)\n",
+// Object,ObjectType);
+
+ Header = BODY_TO_HEADER(Object);
+
+ if (ObjectType != NULL && Header->ObjectType != ObjectType)
+ {
+ DPRINT("Failed %x (type was %x %S) should be %x %S\n",
+ Header,
+ Header->ObjectType,
+ Header->ObjectType->TypeName.Buffer,
+ ObjectType,
+ ObjectType->TypeName.Buffer);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ if (Header->ObjectType == PsProcessType)
+ {
+ DPRINT("Ref p 0x%x refcount %d type %x ",
+ Object, Header->RefCount, PsProcessType);
+ DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
+ }
+ if (Header->ObjectType == PsThreadType)
+ {
+ DPRINT("Deref t 0x%x with refcount %d type %x ",
+ Object, Header->RefCount, PsThreadType);
+ DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
+ }
+
+ Header->RefCount++;
- Object = BODY_TO_HEADER(ObjectBody);
- Object->RefCount++;
return(STATUS_SUCCESS);
}
-NTSTATUS ObPerformRetentionChecks(POBJECT_HEADER Header)
+
+NTSTATUS STDCALL
+ObOpenObjectByPointer(IN POBJECT Object,
+ IN ULONG HandleAttributes,
+ IN PACCESS_STATE PassedAccessState,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_TYPE ObjectType,
+ IN KPROCESSOR_MODE AccessMode,
+ OUT PHANDLE Handle)
{
- if (Header->RefCount == 0 && Header->HandleCount == 0 &&
- !Header->Permanent)
+ NTSTATUS Status;
+
+ DPRINT("ObOpenObjectByPointer()\n");
+
+ Status = ObReferenceObjectByPointer(Object,
+ 0,
+ ObjectType,
+ AccessMode);
+ if (!NT_SUCCESS(Status))
{
- ObRemoveEntry(Header);
- ExFreePool(Header);
+ return Status;
}
- return(STATUS_SUCCESS);
+
+ Status = ObCreateHandle(PsGetCurrentProcess(),
+ Object,
+ DesiredAccess,
+ FALSE,
+ Handle);
+
+ ObDereferenceObject(Object);
+
+ return STATUS_SUCCESS;
}
-VOID ObDereferenceObject(PVOID ObjectBody)
-/*
- * FUNCTION: Decrements a given object's reference count and performs
- * retention checks
- * ARGUMENTS:
- * ObjectBody = Body of the object
+
+static NTSTATUS
+ObpPerformRetentionChecks(POBJECT_HEADER Header)
+{
+// DPRINT("ObPerformRetentionChecks(Header %x), RefCount %d, HandleCount %d\n",
+// Header,Header->RefCount,Header->HandleCount);
+
+ if (Header->RefCount < 0)
+ {
+ CPRINT("Object %x/%x has invalid reference count (%d)\n",
+ Header, HEADER_TO_BODY(Header), Header->RefCount);
+ KeBugCheck(0);
+ }
+ if (Header->HandleCount < 0)
+ {
+ CPRINT("Object %x/%x has invalid handle count (%d)\n",
+ Header, HEADER_TO_BODY(Header), Header->HandleCount);
+ KeBugCheck(0);
+ }
+
+ if (Header->RefCount == 0 &&
+ Header->HandleCount == 0 &&
+ Header->Permanent == FALSE)
+ {
+ if (Header->ObjectType != NULL &&
+ Header->ObjectType->Delete != NULL)
+ {
+ Header->ObjectType->Delete(HEADER_TO_BODY(Header));
+ }
+ if (Header->Name.Buffer != NULL)
+ {
+ ObpRemoveEntryDirectory(Header);
+ RtlFreeUnicodeString(&Header->Name);
+ }
+ DPRINT("ObPerformRetentionChecks() = Freeing object\n");
+ ExFreePool(Header);
+ }
+ return(STATUS_SUCCESS);
+}
+
+
+/**********************************************************************
+ * NAME EXPORTED
+ * ObfReferenceObject@4
+ *
+ * DESCRIPTION
+ * Increments a given object's reference count and performs
+ * retention checks.
+ *
+ * ARGUMENTS
+ * ObjectBody = Body of the object.
+ *
+ * RETURN VALUE
+ * None.
*/
+VOID FASTCALL
+ObfReferenceObject(IN PVOID Object)
{
- POBJECT_HEADER Header = BODY_TO_HEADER(ObjectBody);
- Header->RefCount--;
- ObPerformRetentionChecks(Header);
+ POBJECT_HEADER Header;
+
+ assert(Object);
+
+ Header = BODY_TO_HEADER(Object);
+
+ Header->RefCount++;
+
+ ObpPerformRetentionChecks(Header);
}
-NTSTATUS NtClose(HANDLE Handle)
+/**********************************************************************
+ * NAME EXPORTED
+ * ObfDereferenceObject@4
+ *
+ * DESCRIPTION
+ * Decrements a given object's reference count and performs
+ * retention checks.
+ *
+ * ARGUMENTS
+ * ObjectBody = Body of the object.
+ *
+ * RETURN VALUE
+ * None.
+ */
+VOID FASTCALL
+ObfDereferenceObject(IN PVOID Object)
{
- return(ZwClose(Handle));
+ POBJECT_HEADER Header;
+ extern POBJECT_TYPE PsProcessType;
+
+ assert(Object);
+
+ Header = BODY_TO_HEADER(Object);
+
+ if (Header->ObjectType == PsProcessType)
+ {
+ DPRINT("Deref p 0x%x with refcount %d type %x ",
+ Object, Header->RefCount, PsProcessType);
+ DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
+ }
+ if (Header->ObjectType == PsThreadType)
+ {
+ DPRINT("Deref t 0x%x with refcount %d type %x ",
+ Object, Header->RefCount, PsThreadType);
+ DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
+ }
+
+ Header->RefCount--;
+
+ ObpPerformRetentionChecks(Header);
}
-NTSTATUS ZwClose(HANDLE Handle)
-/*
- * FUNCTION: Closes a handle reference to an object
- * ARGUMENTS:
- * Handle = handle to close
- * RETURNS: Status
+
+/**********************************************************************
+ * NAME EXPORTED
+ * ObGetObjectPointerCount@4
+ *
+ * DESCRIPTION
+ * Retrieves the pointer(reference) count of the given object.
+ *
+ * ARGUMENTS
+ * ObjectBody = Body of the object.
+ *
+ * RETURN VALUE
+ * Reference count.
*/
+ULONG STDCALL
+ObGetObjectPointerCount(PVOID Object)
{
- PVOID ObjectBody;
- POBJECT_HEADER Header;
- PHANDLE_REP HandleRep;
-
- assert_irql(PASSIVE_LEVEL);
-
- HandleRep = ObTranslateHandle(KeGetCurrentProcess(),Handle);
- if (HandleRep == NULL)
- {
- return(STATUS_INVALID_HANDLE);
- }
- ObjectBody = HandleRep->ObjectBody;
-
- HandleRep->ObjectBody = NULL;
-
- Header = BODY_TO_HEADER(ObjectBody);
-
- Header->HandleCount--;
- ObPerformRetentionChecks(Header);
-
- return(STATUS_SUCCESS);
+ POBJECT_HEADER Header;
+
+ assert(Object);
+ Header = BODY_TO_HEADER(Object);
+
+ return(Header->RefCount);
}
-NTSTATUS ObReferenceObjectByHandle(HANDLE Handle,
- ACCESS_MASK DesiredAccess,
- POBJECT_TYPE ObjectType,
- KPROCESSOR_MODE AccessMode,
- PVOID* Object,
- POBJECT_HANDLE_INFORMATION
- HandleInformationPtr
- )
-/*
- * FUNCTION: Increments the reference count for an object and returns a
- * pointer to its body
- * ARGUMENTS:
- * Handle = Handle for the object
- * DesiredAccess = Desired access to the object
- * ObjectType
- * AccessMode
- * Object (OUT) = Points to the object body on return
- * HandleInformation (OUT) = Contains information about the handle
- * on return
- * RETURNS: Status
+
+/**********************************************************************
+ * NAME INTERNAL
+ * ObGetObjectHandleCount@4
+ *
+ * DESCRIPTION
+ * Retrieves the handle count of the given object.
+ *
+ * ARGUMENTS
+ * ObjectBody = Body of the object.
+ *
+ * RETURN VALUE
+ * Reference count.
*/
+ULONG
+ObGetObjectHandleCount(PVOID Object)
{
- PHANDLE_REP HandleRep;
- POBJECT_HEADER ObjectHeader;
-
- ASSERT_IRQL(PASSIVE_LEVEL);
-
- DPRINT("ObReferenceObjectByHandle(Handle %x, DesiredAccess %x, "
- "ObjectType %x, AccessMode %d, Object %x)\n",Handle,DesiredAccess,
- ObjectType,AccessMode,Object);
-
- if (Handle == NtCurrentProcess())
- {
- *Object = PsGetCurrentProcess();
- return(STATUS_SUCCESS);
- }
- if (Handle == NtCurrentThread())
- {
- *Object = PsGetCurrentThread();
- return(STATUS_SUCCESS);
- }
-
- HandleRep = ObTranslateHandle(KeGetCurrentProcess(),Handle);
- if (HandleRep == NULL || HandleRep->ObjectBody == NULL)
- {
- return(STATUS_INVALID_HANDLE);
- }
-
- ObjectHeader = BODY_TO_HEADER(HandleRep->ObjectBody);
-
- if (ObjectType != NULL && ObjectType != ObjectHeader->ObjectType)
- {
- return(STATUS_UNSUCCESSFUL);
- }
-
- if (!(HandleRep->GrantedAccess & DesiredAccess))
- {
- return(STATUS_ACCESS_DENIED);
- }
-
- ObjectHeader->RefCount++;
-
- *Object = HandleRep->ObjectBody;
-
- return(STATUS_SUCCESS);
+ POBJECT_HEADER Header;
+
+ assert(Object);
+ Header = BODY_TO_HEADER(Object);
+
+ return(Header->HandleCount);
}
+
+/* EOF */
projects / reactos.git / blobdiff