reactos/lib/rtl/handle.c

   1 /* COPYRIGHT:       See COPYING in the top level directory
   2  * PROJECT:         ReactOS system libraries
   3  * PURPOSE:         Handle table
   4  * FILE:            lib/rtl/handle.c
   5  * PROGRAMER:       Eric Kohl <ekohl@rz-online.de>
   6  */
   7
   8 /* INCLUDES *****************************************************************/
   9
  10 #include <rtl.h>
  11
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* GLOBALS ******************************************************************/
  16
  17 VOID NTAPI
  18 RtlInitializeHandleTable(ULONG TableSize,
  19                          ULONG HandleSize,
  20                          PRTL_HANDLE_TABLE HandleTable)
  21 {
  22    /* initialize handle table */
  23    memset(HandleTable,
  24           0,
  25           sizeof(RTL_HANDLE_TABLE));
  26    HandleTable->MaximumNumberOfHandles = TableSize;
  27    HandleTable->SizeOfHandleTableEntry = HandleSize;
  28 }
  29
  30
  31 /*
  32  * @implemented
  33  */
  34 VOID NTAPI
  35 RtlDestroyHandleTable(PRTL_HANDLE_TABLE HandleTable)
  36 {
  37    PVOID ArrayPointer;
  38    ULONG ArraySize;
  39
  40    /* free handle array */
  41    if (HandleTable->CommittedHandles)
  42      {
  43         ArrayPointer = (PVOID)HandleTable->CommittedHandles;
  44         ArraySize = HandleTable->SizeOfHandleTableEntry * HandleTable->MaximumNumberOfHandles;
  45         NtFreeVirtualMemory(NtCurrentProcess(),
  46                             &ArrayPointer,
  47                             &ArraySize,
  48                             MEM_RELEASE);
  49      }
  50 }
  51
  52
  53 /*
  54  * @implemented
  55  */
  56 PRTL_HANDLE_TABLE_ENTRY NTAPI
  57 RtlAllocateHandle(PRTL_HANDLE_TABLE HandleTable,
  58                   PULONG Index)
  59 {
  60    PRTL_HANDLE_TABLE_ENTRY *pp_new, *pph, ph;
  61    NTSTATUS Status;
  62    PRTL_HANDLE_TABLE_ENTRY retval;
  63    PVOID ArrayPointer;
  64    ULONG ArraySize;
  65
  66    pp_new = &HandleTable->FreeHandles;
  67
  68    if (HandleTable->FreeHandles == NULL)
  69      {
  70         /* no free handle available */
  71         if (HandleTable->UnCommittedHandles == NULL)
  72           {
  73              /* allocate handle array */
  74              ArraySize = HandleTable->SizeOfHandleTableEntry * HandleTable->MaximumNumberOfHandles;
  75              ArrayPointer = NULL;
  76
  77              /* FIXME - only reserve handles here! */
  78              Status = NtAllocateVirtualMemory(NtCurrentProcess(),
  79                                               (PVOID*)&ArrayPointer,
  80                                               0,
  81                                               &ArraySize,
  82                                               MEM_RESERVE | MEM_COMMIT,
  83                                               PAGE_READWRITE);
  84              if (!NT_SUCCESS(Status))
  85                return NULL;
  86
  87              /* update handle array pointers */
  88              HandleTable->FreeHandles = (PRTL_HANDLE_TABLE_ENTRY)ArrayPointer;
  89              HandleTable->MaxReservedHandles = (PRTL_HANDLE_TABLE_ENTRY)((ULONG_PTR)ArrayPointer + ArraySize);
  90              HandleTable->CommittedHandles = (PRTL_HANDLE_TABLE_ENTRY)ArrayPointer;
  91              HandleTable->UnCommittedHandles = (PRTL_HANDLE_TABLE_ENTRY)ArrayPointer;
  92           }
  93
  94         /* FIXME - should check if handles need to be committed */
  95
  96         /* build free list in handle array */
  97         ph = HandleTable->FreeHandles;
  98         pph = pp_new;
  99         while (ph < HandleTable->MaxReservedHandles)
 100           {
 101              *pph = ph;
 102              pph = &ph->NextFree;
 103              ph = (PRTL_HANDLE_TABLE_ENTRY)((ULONG_PTR)ph + HandleTable->SizeOfHandleTableEntry);
 104           }
 105         *pph = 0;
 106      }
 107
 108    /* remove handle from free list */
 109    retval = *pp_new;
 110    *pp_new = retval->NextFree;
 111    retval->NextFree = NULL;
 112
 113    if (Index)
 114      *Index = ((ULONG)((ULONG_PTR)retval - (ULONG_PTR)HandleTable->CommittedHandles) /
 115                HandleTable->SizeOfHandleTableEntry);
 116
 117    return retval;
 118 }
 119
 120
 121 /*
 122  * @implemented
 123  */
 124 BOOLEAN NTAPI
 125 RtlFreeHandle(PRTL_HANDLE_TABLE HandleTable,
 126               PRTL_HANDLE_TABLE_ENTRY Handle)
 127 {
 128 #ifdef DBG
 129    /* check if handle is valid */
 130    if (RtlIsValidHandle(HandleTable, Handle))
 131      return FALSE;
 132 #endif
 133
 134    /* clear handle */
 135    memset(Handle, 0, HandleTable->SizeOfHandleTableEntry);
 136
 137    /* add handle to free list */
 138    Handle->NextFree = HandleTable->FreeHandles;
 139    HandleTable->FreeHandles = Handle;
 140
 141    return TRUE;
 142 }
 143
 144
 145 /*
 146  * @implemented
 147  */
 148 BOOLEAN NTAPI
 149 RtlIsValidHandle(PRTL_HANDLE_TABLE HandleTable,
 150                  PRTL_HANDLE_TABLE_ENTRY Handle)
 151 {
 152    if ((HandleTable != NULL)
 153        && (Handle >= HandleTable->CommittedHandles)
 154        && (Handle < HandleTable->MaxReservedHandles)
 155        && (Handle->Flags & RTL_HANDLE_VALID))
 156      return TRUE;
 157    return FALSE;
 158 }
 159
 160
 161 /*
 162  * @implemented
 163  */
 164 BOOLEAN NTAPI
 165 RtlIsValidIndexHandle(IN PRTL_HANDLE_TABLE HandleTable,
 166                       IN ULONG Index,
 167                       OUT PRTL_HANDLE_TABLE_ENTRY *Handle)
 168 {
 169    PRTL_HANDLE_TABLE_ENTRY InternalHandle;
 170
 171    DPRINT("RtlIsValidIndexHandle(HandleTable %p Index %x Handle %p)\n", HandleTable, Index, Handle);
 172
 173    if (HandleTable == NULL)
 174      return FALSE;
 175
 176    DPRINT("Handles %p HandleSize %x\n",
 177           HandleTable->CommittedHandles, HandleTable->SizeOfHandleTableEntry);
 178
 179    InternalHandle = (PRTL_HANDLE_TABLE_ENTRY)((ULONG_PTR)HandleTable->CommittedHandles +
 180                                               (HandleTable->SizeOfHandleTableEntry * Index));
 181    if (!RtlIsValidHandle(HandleTable, InternalHandle))
 182      return FALSE;
 183
 184    DPRINT("InternalHandle %p\n", InternalHandle);
 185
 186    if (Handle != NULL)
 187      *Handle = InternalHandle;
 188
 189   return TRUE;
 190 }
 191
 192 /* EOF */