reactos/lib/ntdll/rtl/libsupp.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            lib/ntdll/rtl/libsup.c
   5  * PURPOSE:         Rtl library support routines
   6  * PROGRAMMER:      Gunnar Dalsnes
   7  */
   8
   9 /* INCLUDES *****************************************************************/
  10
  11 #include <ntdll.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* FUNCTIONS ***************************************************************/
  16
  17 KPROCESSOR_MODE
  18 STDCALL
  19 RtlpGetMode()
  20 {
  21    return UserMode;
  22 }
  23
  24 PPEB
  25 STDCALL
  26 RtlpCurrentPeb(VOID)
  27 {
  28     return NtCurrentPeb();
  29 }
  30
  31
  32 /*
  33  * @implemented
  34  */
  35 VOID STDCALL
  36 RtlAcquirePebLock(VOID)
  37 {
  38    PPEB Peb = NtCurrentPeb ();
  39    Peb->FastPebLockRoutine (Peb->FastPebLock);
  40 }
  41
  42
  43 /*
  44  * @implemented
  45  */
  46 VOID STDCALL
  47 RtlReleasePebLock(VOID)
  48 {
  49    PPEB Peb = NtCurrentPeb ();
  50    Peb->FastPebUnlockRoutine (Peb->FastPebLock);
  51 }
  52
  53 /*
  54 * @implemented
  55 */
  56 ULONG
  57 STDCALL
  58 RtlGetNtGlobalFlags(VOID)
  59 {
  60         PPEB pPeb = NtCurrentPeb();
  61         return pPeb->NtGlobalFlag;
  62 }
  63
  64 PVOID
  65 STDCALL
  66 RtlpAllocateMemory(UINT Bytes,
  67                    ULONG Tag)
  68 {
  69     UNREFERENCED_PARAMETER(Tag);
  70
  71     return RtlAllocateHeap(RtlGetProcessHeap(),
  72                            0,
  73                            Bytes);
  74 }
  75
  76
  77 VOID
  78 STDCALL
  79 RtlpFreeMemory(PVOID Mem,
  80                ULONG Tag)
  81 {
  82     UNREFERENCED_PARAMETER(Tag);
  83
  84     RtlFreeHeap(RtlGetProcessHeap(),
  85                 0,
  86                 Mem);
  87 }
  88
  89
  90 #ifdef DBG
  91 VOID FASTCALL
  92 CHECK_PAGED_CODE_RTL(char *file, int line)
  93 {
  94   /* meaningless in user mode */
  95 }
  96 #endif
  97
  98 /* RTL Atom Tables ************************************************************/
  99
 100 typedef struct _RTL_ATOM_HANDLE
 101 {
 102    RTL_HANDLE_TABLE_ENTRY Handle;
 103    PRTL_ATOM_TABLE_ENTRY AtomEntry;
 104 } RTL_ATOM_HANDLE, *PRTL_ATOM_HANDLE;
 105
 106 NTSTATUS
 107 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 108 {
 109    RtlInitializeCriticalSection(&AtomTable->CriticalSection);
 110    return STATUS_SUCCESS;
 111 }
 112
 113
 114 VOID
 115 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 116 {
 117    RtlDeleteCriticalSection(&AtomTable->CriticalSection);
 118 }
 119
 120
 121 BOOLEAN
 122 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 123 {
 124    RtlEnterCriticalSection(&AtomTable->CriticalSection);
 125    return TRUE;
 126 }
 127
 128
 129 VOID
 130 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 131 {
 132    RtlLeaveCriticalSection(&AtomTable->CriticalSection);
 133 }
 134
 135
 136 /* handle functions */
 137
 138 BOOLEAN
 139 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 140 {
 141    RtlInitializeHandleTable(0xCFFF,
 142                             sizeof(RTL_ATOM_HANDLE),
 143                             &AtomTable->RtlHandleTable);
 144
 145    return TRUE;
 146 }
 147
 148 VOID
 149 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 150 {
 151    RtlDestroyHandleTable(&AtomTable->RtlHandleTable);
 152 }
 153
 154 PRTL_ATOM_TABLE
 155 RtlpAllocAtomTable(ULONG Size)
 156 {
 157    return (PRTL_ATOM_TABLE)RtlAllocateHeap(RtlGetProcessHeap(),
 158                                            HEAP_ZERO_MEMORY,
 159                                            Size);
 160 }
 161
 162 VOID
 163 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 164 {
 165    RtlFreeHeap(RtlGetProcessHeap(),
 166                0,
 167                AtomTable);
 168 }
 169
 170 PRTL_ATOM_TABLE_ENTRY
 171 RtlpAllocAtomTableEntry(ULONG Size)
 172 {
 173    return (PRTL_ATOM_TABLE_ENTRY)RtlAllocateHeap(RtlGetProcessHeap(),
 174                                                  HEAP_ZERO_MEMORY,
 175                                                  Size);
 176 }
 177
 178 VOID
 179 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 180 {
 181    RtlFreeHeap(RtlGetProcessHeap(),
 182                0,
 183                Entry);
 184 }
 185
 186 VOID
 187 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 188 {
 189    PRTL_HANDLE_TABLE_ENTRY RtlHandleEntry;
 190
 191    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 192                              (ULONG)Entry->HandleIndex,
 193                              &RtlHandleEntry))
 194    {
 195       RtlFreeHandle(&AtomTable->RtlHandleTable,
 196                     RtlHandleEntry);
 197    }
 198 }
 199
 200 BOOLEAN
 201 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 202 {
 203    ULONG HandleIndex;
 204    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 205
 206    RtlHandle = RtlAllocateHandle(&AtomTable->RtlHandleTable,
 207                                  &HandleIndex);
 208    if (RtlHandle != NULL)
 209    {
 210       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 211
 212       /* FIXME - Handle Indexes >= 0xC000 ?! */
 213       if (HandleIndex < 0xC000)
 214       {
 215          Entry->HandleIndex = (USHORT)HandleIndex;
 216          Entry->Atom = 0xC000 + (USHORT)HandleIndex;
 217
 218          AtomHandle->AtomEntry = Entry;
 219          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 220
 221          return TRUE;
 222       }
 223       else
 224       {
 225          /* set the valid flag, otherwise RtlFreeHandle will fail! */
 226          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 227
 228          RtlFreeHandle(&AtomTable->RtlHandleTable,
 229                        RtlHandle);
 230       }
 231    }
 232
 233    return FALSE;
 234 }
 235
 236 PRTL_ATOM_TABLE_ENTRY
 237 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 238 {
 239    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 240
 241    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 242                              Index,
 243                              &RtlHandle))
 244    {
 245       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 246
 247       return AtomHandle->AtomEntry;
 248    }
 249
 250    return NULL;
 251 }
 252