object.c

Go to the documentation of this file.

/*
 * 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 */
    { NULL,                     NULL,                       NULL },                 /* 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;
}