mirror of
https://github.com/reactos/reactos.git
synced 2024-08-29 22:58:34 +00:00
![Katayama Hirofumi MZ](/assets/img/avatar_default.png)
According to JIRA user simonelombardo, there was crash in exiting a thread. - Add UserAssignmentLock, and UserAssignmentUnlock helper functions. - Lock and unlock pti->spDefaultImc by using those helper functions. CORE-18044
840 lines
20 KiB
C
840 lines
20 KiB
C
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS kernel
|
|
* PURPOSE: User handle manager
|
|
* FILE: win32ss/user/ntuser/object.c
|
|
* PROGRAMER: Copyright (C) 2001 Alexandre Julliard
|
|
*/
|
|
|
|
#include <win32k.h>
|
|
DBG_DEFAULT_CHANNEL(UserObj);
|
|
|
|
//int usedHandles=0;
|
|
PUSER_HANDLE_TABLE gHandleTable = NULL;
|
|
|
|
/* Forward declarations */
|
|
_Success_(return!=NULL)
|
|
static PVOID AllocThreadObject(
|
|
_In_ PDESKTOP pDesk,
|
|
_In_ PTHREADINFO pti,
|
|
_In_ SIZE_T Size,
|
|
_Out_ PVOID* HandleOwner)
|
|
{
|
|
PTHROBJHEAD ObjHead;
|
|
|
|
UNREFERENCED_PARAMETER(pDesk);
|
|
|
|
ASSERT(Size > sizeof(*ObjHead));
|
|
ASSERT(pti != NULL);
|
|
|
|
ObjHead = UserHeapAlloc(Size);
|
|
if (!ObjHead)
|
|
return NULL;
|
|
|
|
RtlZeroMemory(ObjHead, Size);
|
|
|
|
ObjHead->pti = pti;
|
|
IntReferenceThreadInfo(pti);
|
|
*HandleOwner = pti;
|
|
/* It's a thread object, but it still count as one for the process */
|
|
pti->ppi->UserHandleCount++;
|
|
|
|
return ObjHead;
|
|
}
|
|
|
|
static void FreeThreadObject(
|
|
_In_ PVOID Object)
|
|
{
|
|
PTHROBJHEAD ObjHead = (PTHROBJHEAD)Object;
|
|
PTHREADINFO pti = ObjHead->pti;
|
|
|
|
UserHeapFree(ObjHead);
|
|
|
|
pti->ppi->UserHandleCount--;
|
|
IntDereferenceThreadInfo(pti);
|
|
}
|
|
|
|
_Success_(return!=NULL)
|
|
static PVOID AllocDeskThreadObject(
|
|
_In_ PDESKTOP pDesk,
|
|
_In_ PTHREADINFO pti,
|
|
_In_ SIZE_T Size,
|
|
_Out_ PVOID* HandleOwner)
|
|
{
|
|
PTHRDESKHEAD ObjHead;
|
|
|
|
ASSERT(Size > sizeof(*ObjHead));
|
|
ASSERT(pti != NULL);
|
|
|
|
if (!pDesk)
|
|
pDesk = pti->rpdesk;
|
|
|
|
ObjHead = DesktopHeapAlloc(pDesk, Size);
|
|
if (!ObjHead)
|
|
return NULL;
|
|
|
|
RtlZeroMemory(ObjHead, Size);
|
|
|
|
ObjHead->pSelf = ObjHead;
|
|
ObjHead->rpdesk = pDesk;
|
|
ObjHead->pti = pti;
|
|
IntReferenceThreadInfo(pti);
|
|
*HandleOwner = pti;
|
|
/* It's a thread object, but it still count as one for the process */
|
|
pti->ppi->UserHandleCount++;
|
|
|
|
return ObjHead;
|
|
}
|
|
|
|
static void FreeDeskThreadObject(
|
|
_In_ PVOID Object)
|
|
{
|
|
PTHRDESKHEAD ObjHead = (PTHRDESKHEAD)Object;
|
|
PDESKTOP pDesk = ObjHead->rpdesk;
|
|
PTHREADINFO pti = ObjHead->pti;
|
|
|
|
DesktopHeapFree(pDesk, Object);
|
|
|
|
pti->ppi->UserHandleCount--;
|
|
IntDereferenceThreadInfo(pti);
|
|
}
|
|
|
|
_Success_(return!=NULL)
|
|
static PVOID AllocDeskProcObject(
|
|
_In_ PDESKTOP pDesk,
|
|
_In_ PTHREADINFO pti,
|
|
_In_ SIZE_T Size,
|
|
_Out_ PVOID* HandleOwner)
|
|
{
|
|
PPROCDESKHEAD ObjHead;
|
|
PPROCESSINFO ppi;
|
|
|
|
ASSERT(Size > sizeof(*ObjHead));
|
|
ASSERT(pDesk != NULL);
|
|
ASSERT(pti != NULL);
|
|
|
|
ObjHead = DesktopHeapAlloc(pDesk, Size);
|
|
if (!ObjHead)
|
|
return NULL;
|
|
|
|
RtlZeroMemory(ObjHead, Size);
|
|
|
|
ppi = pti->ppi;
|
|
|
|
ObjHead->pSelf = ObjHead;
|
|
ObjHead->rpdesk = pDesk;
|
|
ObjHead->hTaskWow = (DWORD_PTR)ppi;
|
|
ppi->UserHandleCount++;
|
|
IntReferenceProcessInfo(ppi);
|
|
*HandleOwner = ppi;
|
|
|
|
return ObjHead;
|
|
}
|
|
|
|
static void FreeDeskProcObject(
|
|
_In_ PVOID Object)
|
|
{
|
|
PPROCDESKHEAD ObjHead = (PPROCDESKHEAD)Object;
|
|
PDESKTOP pDesk = ObjHead->rpdesk;
|
|
PPROCESSINFO ppi = (PPROCESSINFO)ObjHead->hTaskWow;
|
|
|
|
ppi->UserHandleCount--;
|
|
IntDereferenceProcessInfo(ppi);
|
|
|
|
DesktopHeapFree(pDesk, Object);
|
|
}
|
|
|
|
_Success_(return!=NULL)
|
|
static PVOID AllocProcMarkObject(
|
|
_In_ PDESKTOP pDesk,
|
|
_In_ PTHREADINFO pti,
|
|
_In_ SIZE_T Size,
|
|
_Out_ PVOID* HandleOwner)
|
|
{
|
|
PPROCMARKHEAD ObjHead;
|
|
PPROCESSINFO ppi = pti->ppi;
|
|
|
|
UNREFERENCED_PARAMETER(pDesk);
|
|
|
|
ASSERT(Size > sizeof(*ObjHead));
|
|
|
|
ObjHead = UserHeapAlloc(Size);
|
|
if (!ObjHead)
|
|
return NULL;
|
|
|
|
RtlZeroMemory(ObjHead, Size);
|
|
|
|
ObjHead->ppi = ppi;
|
|
IntReferenceProcessInfo(ppi);
|
|
*HandleOwner = ppi;
|
|
ppi->UserHandleCount++;
|
|
|
|
return ObjHead;
|
|
}
|
|
|
|
void FreeProcMarkObject(
|
|
_In_ PVOID Object)
|
|
{
|
|
PPROCESSINFO ppi = ((PPROCMARKHEAD)Object)->ppi;
|
|
|
|
UserHeapFree(Object);
|
|
|
|
ppi->UserHandleCount--;
|
|
IntDereferenceProcessInfo(ppi);
|
|
}
|
|
|
|
_Success_(return!=NULL)
|
|
static PVOID AllocSysObject(
|
|
_In_ PDESKTOP pDesk,
|
|
_In_ PTHREADINFO pti,
|
|
_In_ SIZE_T Size,
|
|
_Out_ PVOID* ObjectOwner)
|
|
{
|
|
PVOID Object;
|
|
|
|
UNREFERENCED_PARAMETER(pDesk);
|
|
UNREFERENCED_PARAMETER(pti);
|
|
|
|
ASSERT(Size > sizeof(HEAD));
|
|
|
|
Object = UserHeapAlloc(Size);
|
|
if (!Object)
|
|
return NULL;
|
|
|
|
*ObjectOwner = NULL;
|
|
|
|
RtlZeroMemory(Object, Size);
|
|
return Object;
|
|
}
|
|
|
|
static void FreeSysObject(
|
|
_In_ PVOID Object)
|
|
{
|
|
UserHeapFree(Object);
|
|
}
|
|
|
|
static const struct
|
|
{
|
|
PVOID (*ObjectAlloc)(PDESKTOP, PTHREADINFO, SIZE_T, PVOID*);
|
|
BOOLEAN (*ObjectDestroy)(PVOID);
|
|
void (*ObjectFree)(PVOID);
|
|
} ObjectCallbacks[TYPE_CTYPES] =
|
|
{
|
|
{ NULL, NULL, NULL }, /* TYPE_FREE */
|
|
{ AllocDeskThreadObject, co_UserDestroyWindow, FreeDeskThreadObject }, /* TYPE_WINDOW */
|
|
{ AllocDeskProcObject, UserDestroyMenuObject, FreeDeskProcObject }, /* TYPE_MENU */
|
|
{ AllocProcMarkObject, IntDestroyCurIconObject, FreeCurIconObject }, /* TYPE_CURSOR */
|
|
{ AllocSysObject, /*UserSetWindowPosCleanup*/NULL, FreeSysObject }, /* TYPE_SETWINDOWPOS */
|
|
{ AllocDeskThreadObject, IntRemoveHook, FreeDeskThreadObject }, /* TYPE_HOOK */
|
|
{ AllocSysObject, /*UserClipDataCleanup*/NULL,FreeSysObject }, /* TYPE_CLIPDATA */
|
|
{ AllocDeskProcObject, DestroyCallProc, FreeDeskProcObject }, /* TYPE_CALLPROC */
|
|
{ AllocProcMarkObject, UserDestroyAccelTable, FreeProcMarkObject }, /* TYPE_ACCELTABLE */
|
|
{ NULL, NULL, NULL }, /* TYPE_DDEACCESS */
|
|
{ NULL, NULL, NULL }, /* TYPE_DDECONV */
|
|
{ NULL, NULL, NULL }, /* TYPE_DDEXACT */
|
|
{ AllocSysObject, /*UserMonitorCleanup*/NULL, FreeSysObject }, /* TYPE_MONITOR */
|
|
{ AllocSysObject, /*UserKbdLayoutCleanup*/NULL,FreeSysObject }, /* TYPE_KBDLAYOUT */
|
|
{ AllocSysObject, /*UserKbdFileCleanup*/NULL, FreeSysObject }, /* TYPE_KBDFILE */
|
|
{ AllocThreadObject, IntRemoveEvent, FreeThreadObject }, /* TYPE_WINEVENTHOOK */
|
|
{ AllocSysObject, /*UserTimerCleanup*/NULL, FreeSysObject }, /* TYPE_TIMER */
|
|
{ AllocInputContextObject, UserDestroyInputContext, UserFreeInputContext }, /* TYPE_INPUTCONTEXT */
|
|
{ NULL, NULL, NULL }, /* TYPE_HIDDATA */
|
|
{ NULL, NULL, NULL }, /* TYPE_DEVICEINFO */
|
|
{ NULL, NULL, NULL }, /* TYPE_TOUCHINPUTINFO */
|
|
{ NULL, NULL, NULL }, /* TYPE_GESTUREINFOOBJ */
|
|
};
|
|
|
|
#if DBG
|
|
|
|
void DbgUserDumpHandleTable(VOID)
|
|
{
|
|
int HandleCounts[TYPE_CTYPES];
|
|
PPROCESSINFO ppiList;
|
|
int i;
|
|
PWCHAR TypeNames[] = {L"Free",L"Window",L"Menu", L"CursorIcon", L"SMWP", L"Hook", L"ClipBoardData", L"CallProc",
|
|
L"Accel", L"DDEaccess", L"DDEconv", L"DDExact", L"Monitor", L"KBDlayout", L"KBDfile",
|
|
L"Event", L"Timer", L"InputContext", L"HidData", L"DeviceInfo", L"TouchInput",L"GestureInfo"};
|
|
|
|
ERR("Total handles count: %lu\n", gpsi->cHandleEntries);
|
|
|
|
memset(HandleCounts, 0, sizeof(HandleCounts));
|
|
|
|
/* First of all count the number of handles per type */
|
|
ppiList = gppiList;
|
|
while (ppiList)
|
|
{
|
|
ERR("Process %s (%p) handles count: %d\n\t", ppiList->peProcess->ImageFileName, ppiList->peProcess->UniqueProcessId, ppiList->UserHandleCount);
|
|
|
|
for (i = 1 ;i < TYPE_CTYPES; i++)
|
|
{
|
|
HandleCounts[i] += ppiList->DbgHandleCount[i];
|
|
|
|
DbgPrint("%S: %lu, ", TypeNames[i], ppiList->DbgHandleCount[i]);
|
|
if (i % 6 == 0)
|
|
DbgPrint("\n\t");
|
|
}
|
|
DbgPrint("\n");
|
|
|
|
ppiList = ppiList->ppiNext;
|
|
}
|
|
|
|
/* Print total type counts */
|
|
ERR("Total handles of the running processes: \n\t");
|
|
for (i = 1 ;i < TYPE_CTYPES; i++)
|
|
{
|
|
DbgPrint("%S: %d, ", TypeNames[i], HandleCounts[i]);
|
|
if (i % 6 == 0)
|
|
DbgPrint("\n\t");
|
|
}
|
|
DbgPrint("\n");
|
|
|
|
/* Now count the handle counts that are allocated from the handle table */
|
|
memset(HandleCounts, 0, sizeof(HandleCounts));
|
|
for (i = 0; i < gHandleTable->nb_handles; i++)
|
|
HandleCounts[gHandleTable->handles[i].type]++;
|
|
|
|
ERR("Total handles count allocated: \n\t");
|
|
for (i = 1 ;i < TYPE_CTYPES; i++)
|
|
{
|
|
DbgPrint("%S: %d, ", TypeNames[i], HandleCounts[i]);
|
|
if (i % 6 == 0)
|
|
DbgPrint("\n\t");
|
|
}
|
|
DbgPrint("\n");
|
|
}
|
|
|
|
#endif
|
|
|
|
PUSER_HANDLE_ENTRY handle_to_entry(PUSER_HANDLE_TABLE ht, HANDLE handle )
|
|
{
|
|
unsigned short generation;
|
|
int index = (LOWORD(handle) - FIRST_USER_HANDLE) >> 1;
|
|
if (index < 0 || index >= ht->nb_handles)
|
|
return NULL;
|
|
if (!ht->handles[index].type)
|
|
return NULL;
|
|
generation = HIWORD(handle);
|
|
if (generation == ht->handles[index].generation || !generation || generation == 0xffff)
|
|
return &ht->handles[index];
|
|
return NULL;
|
|
}
|
|
|
|
__inline static HANDLE entry_to_handle(PUSER_HANDLE_TABLE ht, PUSER_HANDLE_ENTRY ptr )
|
|
{
|
|
int index = ptr - ht->handles;
|
|
return (HANDLE)((((INT_PTR)index << 1) + FIRST_USER_HANDLE) + (ptr->generation << 16));
|
|
}
|
|
|
|
__inline static PUSER_HANDLE_ENTRY alloc_user_entry(PUSER_HANDLE_TABLE ht)
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
TRACE("handles used %lu\n", gpsi->cHandleEntries);
|
|
|
|
if (ht->freelist)
|
|
{
|
|
entry = ht->freelist;
|
|
ht->freelist = entry->ptr;
|
|
|
|
gpsi->cHandleEntries++;
|
|
return entry;
|
|
}
|
|
|
|
if (ht->nb_handles >= ht->allocated_handles) /* Need to grow the array */
|
|
{
|
|
ERR("Out of user handles! Used -> %lu, NM_Handle -> %d\n", gpsi->cHandleEntries, ht->nb_handles);
|
|
|
|
#if DBG
|
|
DbgUserDumpHandleTable();
|
|
#endif
|
|
|
|
return NULL;
|
|
#if 0
|
|
PUSER_HANDLE_ENTRY new_handles;
|
|
/* Grow array by 50% (but at minimum 32 entries) */
|
|
int growth = max( 32, ht->allocated_handles / 2 );
|
|
int new_size = min( ht->allocated_handles + growth, (LAST_USER_HANDLE-FIRST_USER_HANDLE+1) >> 1 );
|
|
if (new_size <= ht->allocated_handles)
|
|
return NULL;
|
|
if (!(new_handles = UserHeapReAlloc( ht->handles, new_size * sizeof(*ht->handles) )))
|
|
return NULL;
|
|
ht->handles = new_handles;
|
|
ht->allocated_handles = new_size;
|
|
#endif
|
|
}
|
|
|
|
entry = &ht->handles[ht->nb_handles++];
|
|
|
|
entry->generation = 1;
|
|
|
|
gpsi->cHandleEntries++;
|
|
|
|
return entry;
|
|
}
|
|
|
|
VOID UserInitHandleTable(PUSER_HANDLE_TABLE ht, PVOID mem, ULONG bytes)
|
|
{
|
|
ht->freelist = NULL;
|
|
ht->handles = mem;
|
|
|
|
ht->nb_handles = 0;
|
|
ht->allocated_handles = bytes / sizeof(USER_HANDLE_ENTRY);
|
|
}
|
|
|
|
|
|
__inline static void *free_user_entry(PUSER_HANDLE_TABLE ht, PUSER_HANDLE_ENTRY entry)
|
|
{
|
|
void *ret;
|
|
|
|
#if DBG
|
|
{
|
|
PPROCESSINFO ppi;
|
|
switch (entry->type)
|
|
{
|
|
case TYPE_WINDOW:
|
|
case TYPE_HOOK:
|
|
case TYPE_WINEVENTHOOK:
|
|
ppi = ((PTHREADINFO)entry->pi)->ppi;
|
|
break;
|
|
case TYPE_MENU:
|
|
case TYPE_CURSOR:
|
|
case TYPE_CALLPROC:
|
|
case TYPE_ACCELTABLE:
|
|
ppi = entry->pi;
|
|
break;
|
|
default:
|
|
ppi = NULL;
|
|
}
|
|
if (ppi)
|
|
ppi->DbgHandleCount[entry->type]--;
|
|
}
|
|
#endif
|
|
|
|
ret = entry->ptr;
|
|
entry->ptr = ht->freelist;
|
|
entry->type = 0;
|
|
entry->flags = 0;
|
|
entry->pi = NULL;
|
|
ht->freelist = entry;
|
|
|
|
gpsi->cHandleEntries--;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* allocate a user handle for a given object */
|
|
HANDLE UserAllocHandle(
|
|
_Inout_ PUSER_HANDLE_TABLE ht,
|
|
_In_ PVOID object,
|
|
_In_ HANDLE_TYPE type,
|
|
_In_ PVOID HandleOwner)
|
|
{
|
|
PUSER_HANDLE_ENTRY entry = alloc_user_entry(ht);
|
|
if (!entry)
|
|
return 0;
|
|
entry->ptr = object;
|
|
entry->type = type;
|
|
entry->flags = 0;
|
|
entry->pi = HandleOwner;
|
|
if (++entry->generation >= 0xffff)
|
|
entry->generation = 1;
|
|
|
|
/* We have created a handle, which is a reference! */
|
|
UserReferenceObject(object);
|
|
|
|
return entry_to_handle(ht, entry );
|
|
}
|
|
|
|
/* return a pointer to a user object from its handle without setting an error */
|
|
PVOID UserGetObjectNoErr(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type )
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
ASSERT(ht);
|
|
|
|
if (!(entry = handle_to_entry(ht, handle )) || entry->type != type)
|
|
{
|
|
return NULL;
|
|
}
|
|
return entry->ptr;
|
|
}
|
|
|
|
/* return a pointer to a user object from its handle */
|
|
PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type )
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
ASSERT(ht);
|
|
|
|
if (!(entry = handle_to_entry(ht, handle )) || entry->type != type)
|
|
{
|
|
EngSetLastError(ERROR_INVALID_HANDLE);
|
|
return NULL;
|
|
}
|
|
return entry->ptr;
|
|
}
|
|
|
|
|
|
/* Get the full handle (32bit) for a possibly truncated (16bit) handle */
|
|
HANDLE get_user_full_handle(PUSER_HANDLE_TABLE ht, HANDLE handle )
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
if ((ULONG_PTR)handle >> 16)
|
|
return handle;
|
|
if (!(entry = handle_to_entry(ht, handle )))
|
|
return handle;
|
|
return entry_to_handle( ht, entry );
|
|
}
|
|
|
|
|
|
/* Same as get_user_object plus set the handle to the full 32-bit value */
|
|
void *get_user_object_handle(PUSER_HANDLE_TABLE ht, HANDLE* handle, HANDLE_TYPE type )
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
if (!(entry = handle_to_entry(ht, *handle )) || entry->type != type)
|
|
return NULL;
|
|
*handle = entry_to_handle( ht, entry );
|
|
return entry->ptr;
|
|
}
|
|
|
|
|
|
|
|
BOOL FASTCALL UserCreateHandleTable(VOID)
|
|
{
|
|
PVOID mem;
|
|
INT HandleCount = 1024 * 4;
|
|
|
|
// FIXME: Don't alloc all at once! Must be mapped into umode also...
|
|
mem = UserHeapAlloc(sizeof(USER_HANDLE_ENTRY) * HandleCount);
|
|
if (!mem)
|
|
{
|
|
ERR("Failed creating handle table\n");
|
|
return FALSE;
|
|
}
|
|
|
|
gHandleTable = UserHeapAlloc(sizeof(USER_HANDLE_TABLE));
|
|
if (gHandleTable == NULL)
|
|
{
|
|
UserHeapFree(mem);
|
|
ERR("Failed creating handle table\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// FIXME: Make auto growable
|
|
UserInitHandleTable(gHandleTable, mem, sizeof(USER_HANDLE_ENTRY) * HandleCount);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// New
|
|
//
|
|
PVOID
|
|
FASTCALL
|
|
UserCreateObject( PUSER_HANDLE_TABLE ht,
|
|
PDESKTOP pDesktop,
|
|
PTHREADINFO pti,
|
|
HANDLE* h,
|
|
HANDLE_TYPE type,
|
|
ULONG size)
|
|
{
|
|
HANDLE hi;
|
|
PVOID Object;
|
|
PVOID ObjectOwner;
|
|
|
|
/* Some sanity checks. Other checks will be made in the allocator */
|
|
ASSERT(type < TYPE_CTYPES);
|
|
ASSERT(type != TYPE_FREE);
|
|
ASSERT(ht != NULL);
|
|
|
|
/* Allocate the object */
|
|
ASSERT(ObjectCallbacks[type].ObjectAlloc != NULL);
|
|
Object = ObjectCallbacks[type].ObjectAlloc(pDesktop, pti, size, &ObjectOwner);
|
|
if (!Object)
|
|
{
|
|
ERR("User object allocation failed. Out of memory!\n");
|
|
return NULL;
|
|
}
|
|
|
|
hi = UserAllocHandle(ht, Object, type, ObjectOwner);
|
|
if (hi == NULL)
|
|
{
|
|
ERR("Out of user handles!\n");
|
|
ObjectCallbacks[type].ObjectFree(Object);
|
|
return NULL;
|
|
}
|
|
|
|
#if DBG
|
|
if (pti)
|
|
pti->ppi->DbgHandleCount[type]++;
|
|
#endif
|
|
|
|
/* Give this object its identity. */
|
|
((PHEAD)Object)->h = hi;
|
|
|
|
/* The caller will get a locked object.
|
|
* Note: with the reference from the handle, that makes two */
|
|
UserReferenceObject(Object);
|
|
|
|
if (h)
|
|
*h = hi;
|
|
return Object;
|
|
}
|
|
|
|
BOOL
|
|
FASTCALL
|
|
UserMarkObjectDestroy(PVOID Object)
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
PHEAD ObjHead = Object;
|
|
|
|
entry = handle_to_entry(gHandleTable, ObjHead->h);
|
|
|
|
ASSERT(entry != NULL);
|
|
|
|
entry->flags |= HANDLEENTRY_DESTROY;
|
|
|
|
if (ObjHead->cLockObj > 1)
|
|
{
|
|
entry->flags &= ~HANDLEENTRY_INDESTROY;
|
|
TRACE("Count %d\n",ObjHead->cLockObj);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
FASTCALL
|
|
UserDereferenceObject(PVOID Object)
|
|
{
|
|
PHEAD ObjHead = Object;
|
|
|
|
ASSERT(ObjHead->cLockObj >= 1);
|
|
ASSERT(ObjHead->cLockObj < 0x10000);
|
|
|
|
if (--ObjHead->cLockObj == 0)
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
HANDLE_TYPE type;
|
|
|
|
entry = handle_to_entry(gHandleTable, ObjHead->h);
|
|
|
|
ASSERT(entry != NULL);
|
|
/* The entry should be marked as in deletion */
|
|
ASSERT(entry->flags & HANDLEENTRY_INDESTROY);
|
|
|
|
type = entry->type;
|
|
ASSERT(type != TYPE_FREE);
|
|
ASSERT(type < TYPE_CTYPES);
|
|
|
|
/* We can now get rid of everything */
|
|
free_user_entry(gHandleTable, entry );
|
|
|
|
#if 0
|
|
/* Call the object destructor */
|
|
ASSERT(ObjectCallbacks[type].ObjectCleanup != NULL);
|
|
ObjectCallbacks[type].ObjectCleanup(Object);
|
|
#endif
|
|
|
|
/* And free it */
|
|
ASSERT(ObjectCallbacks[type].ObjectFree != NULL);
|
|
ObjectCallbacks[type].ObjectFree(Object);
|
|
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
FASTCALL
|
|
UserFreeHandle(PUSER_HANDLE_TABLE ht, HANDLE handle )
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
if (!(entry = handle_to_entry( ht, handle )))
|
|
{
|
|
SetLastNtError( STATUS_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
entry->flags = HANDLEENTRY_INDESTROY;
|
|
|
|
return UserDereferenceObject(entry->ptr);
|
|
}
|
|
|
|
BOOL
|
|
FASTCALL
|
|
UserObjectInDestroy(HANDLE h)
|
|
{
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
if (!(entry = handle_to_entry( gHandleTable, h )))
|
|
{
|
|
SetLastNtError( STATUS_INVALID_HANDLE );
|
|
return TRUE;
|
|
}
|
|
return (entry->flags & HANDLEENTRY_INDESTROY);
|
|
}
|
|
|
|
BOOL
|
|
FASTCALL
|
|
UserDeleteObject(HANDLE h, HANDLE_TYPE type )
|
|
{
|
|
PVOID body = UserGetObject(gHandleTable, h, type);
|
|
|
|
if (!body) return FALSE;
|
|
|
|
ASSERT( ((PHEAD)body)->cLockObj >= 1);
|
|
ASSERT( ((PHEAD)body)->cLockObj < 0x10000);
|
|
|
|
return UserFreeHandle(gHandleTable, h);
|
|
}
|
|
|
|
VOID
|
|
FASTCALL
|
|
UserReferenceObject(PVOID obj)
|
|
{
|
|
PHEAD ObjHead = obj;
|
|
ASSERT(ObjHead->cLockObj < 0x10000);
|
|
|
|
ObjHead->cLockObj++;
|
|
}
|
|
|
|
PVOID
|
|
FASTCALL
|
|
UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type)
|
|
{
|
|
PVOID object;
|
|
|
|
object = UserGetObject(gHandleTable, handle, type);
|
|
if (object)
|
|
{
|
|
UserReferenceObject(object);
|
|
}
|
|
return object;
|
|
}
|
|
|
|
BOOLEAN
|
|
UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner)
|
|
{
|
|
int i;
|
|
PUSER_HANDLE_ENTRY Entry;
|
|
BOOLEAN Ret = TRUE;
|
|
|
|
/* Sweep the whole handle table */
|
|
for (i = 0; i < Table->allocated_handles; i++)
|
|
{
|
|
Entry = &Table->handles[i];
|
|
|
|
if (Entry->pi != Owner)
|
|
continue;
|
|
|
|
/* Do not destroy if it's already been done */
|
|
if (Entry->flags & HANDLEENTRY_INDESTROY)
|
|
continue;
|
|
|
|
/* Call destructor */
|
|
if (!ObjectCallbacks[Entry->type].ObjectDestroy(Entry->ptr))
|
|
{
|
|
ERR("Failed destructing object %p, type %u.\n", Entry->ptr, Entry->type);
|
|
/* Don't return immediately, we must continue destroying the other objects */
|
|
Ret = FALSE;
|
|
}
|
|
}
|
|
|
|
return Ret;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Status
|
|
* @implemented
|
|
*/
|
|
|
|
BOOL
|
|
APIENTRY
|
|
NtUserValidateHandleSecure(
|
|
HANDLE handle)
|
|
{
|
|
UINT uType;
|
|
PPROCESSINFO ppi;
|
|
PUSER_HANDLE_ENTRY entry;
|
|
|
|
DECLARE_RETURN(BOOL);
|
|
UserEnterExclusive();
|
|
|
|
if (!(entry = handle_to_entry(gHandleTable, handle )))
|
|
{
|
|
EngSetLastError(ERROR_INVALID_HANDLE);
|
|
RETURN( FALSE);
|
|
}
|
|
uType = entry->type;
|
|
switch (uType)
|
|
{
|
|
case TYPE_WINDOW:
|
|
case TYPE_INPUTCONTEXT:
|
|
ppi = ((PTHREADINFO)entry->pi)->ppi;
|
|
break;
|
|
case TYPE_MENU:
|
|
case TYPE_ACCELTABLE:
|
|
case TYPE_CURSOR:
|
|
case TYPE_HOOK:
|
|
case TYPE_CALLPROC:
|
|
case TYPE_SETWINDOWPOS:
|
|
ppi = entry->pi;
|
|
break;
|
|
default:
|
|
ppi = NULL;
|
|
break;
|
|
}
|
|
|
|
if (!ppi) RETURN( FALSE);
|
|
|
|
// Same process job returns TRUE.
|
|
if (gptiCurrent->ppi->pW32Job == ppi->pW32Job) RETURN( TRUE);
|
|
|
|
RETURN( FALSE);
|
|
|
|
CLEANUP:
|
|
UserLeave();
|
|
END_CLEANUP;
|
|
}
|
|
|
|
// Win: HMAssignmentLock
|
|
PVOID FASTCALL UserAssignmentLock(PVOID *ppvObj, PVOID pvNew)
|
|
{
|
|
PVOID pvOld = *ppvObj;
|
|
*ppvObj = pvNew;
|
|
|
|
if (pvOld && pvOld == pvNew)
|
|
return pvOld;
|
|
|
|
if (pvNew)
|
|
UserReferenceObject(pvNew);
|
|
|
|
if (pvOld)
|
|
{
|
|
if (UserDereferenceObject(pvOld))
|
|
pvOld = NULL;
|
|
}
|
|
|
|
return pvOld;
|
|
}
|
|
|
|
// Win: HMAssignmentUnlock
|
|
PVOID FASTCALL UserAssignmentUnlock(PVOID *ppvObj)
|
|
{
|
|
PVOID pvOld = *ppvObj;
|
|
*ppvObj = NULL;
|
|
|
|
if (pvOld)
|
|
{
|
|
if (UserDereferenceObject(pvOld))
|
|
pvOld = NULL;
|
|
}
|
|
|
|
return pvOld;
|
|
}
|