reactos/dll/ntdll/rtl/libsupp.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS NT User-Mode DLL
   4  * FILE:            lib/ntdll/rtl/libsup.c
   5  * PURPOSE:         RTL Support Routines
   6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7  *                  Gunnar Dalsnes
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include <ntdll.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 SIZE_T RtlpAllocDeallocQueryBufferSize = PAGE_SIZE;
  17 PTEB LdrpTopLevelDllBeingLoadedTeb = NULL;
  18
  19 /* FUNCTIONS ***************************************************************/
  20
  21 #ifndef _M_AMD64
  22 // FIXME: Why "Not implemented"???
  23 /*
  24  * @implemented
  25  */
  26 ULONG
  27 NTAPI
  28 RtlWalkFrameChain(OUT PVOID *Callers,
  29                   IN ULONG Count,
  30                   IN ULONG Flags)
  31 {
  32     /* Not implemented for user-mode */
  33     return 0;
  34 }
  35 #endif
  36
  37 BOOLEAN
  38 NTAPI
  39 RtlpCheckForActiveDebugger(VOID)
  40 {
  41     /* Return the flag in the PEB */
  42     return NtCurrentPeb()->BeingDebugged;
  43 }
  44
  45 BOOLEAN
  46 NTAPI
  47 RtlpSetInDbgPrint(VOID)
  48 {
  49     /* Check if it's already set and return TRUE if so */
  50     if (NtCurrentTeb()->InDbgPrint) return TRUE;
  51
  52     /* Set it and return */
  53     NtCurrentTeb()->InDbgPrint = TRUE;
  54     return FALSE;
  55 }
  56
  57 VOID
  58 NTAPI
  59 RtlpClearInDbgPrint(VOID)
  60 {
  61     /* Clear the flag */
  62     NtCurrentTeb()->InDbgPrint = FALSE;
  63 }
  64
  65 KPROCESSOR_MODE
  66 NTAPI
  67 RtlpGetMode()
  68 {
  69    return UserMode;
  70 }
  71
  72 /*
  73  * @implemented
  74  */
  75 PPEB
  76 NTAPI
  77 RtlGetCurrentPeb(VOID)
  78 {
  79     return NtCurrentPeb();
  80 }
  81
  82 /*
  83  * @implemented
  84  */
  85 VOID NTAPI
  86 RtlAcquirePebLock(VOID)
  87 {
  88    PPEB Peb = NtCurrentPeb ();
  89    RtlEnterCriticalSection(Peb->FastPebLock);
  90 }
  91
  92 /*
  93  * @implemented
  94  */
  95 VOID NTAPI
  96 RtlReleasePebLock(VOID)
  97 {
  98    PPEB Peb = NtCurrentPeb ();
  99    RtlLeaveCriticalSection(Peb->FastPebLock);
 100 }
 101
 102 /*
 103 * @implemented
 104 */
 105 ULONG
 106 NTAPI
 107 RtlGetNtGlobalFlags(VOID)
 108 {
 109     PPEB pPeb = NtCurrentPeb();
 110     return pPeb->NtGlobalFlag;
 111 }
 112
 113 NTSTATUS
 114 NTAPI
 115 RtlDeleteHeapLock(
 116     PRTL_CRITICAL_SECTION CriticalSection)
 117 {
 118     return RtlDeleteCriticalSection(CriticalSection);
 119 }
 120
 121 NTSTATUS
 122 NTAPI
 123 RtlEnterHeapLock(
 124     PRTL_CRITICAL_SECTION CriticalSection)
 125 {
 126     return RtlEnterCriticalSection(CriticalSection);
 127 }
 128
 129 NTSTATUS
 130 NTAPI
 131 RtlInitializeHeapLock(
 132     PRTL_CRITICAL_SECTION CriticalSection)
 133 {
 134      return RtlInitializeCriticalSection(CriticalSection);
 135 }
 136
 137 NTSTATUS
 138 NTAPI
 139 RtlLeaveHeapLock(
 140     PRTL_CRITICAL_SECTION CriticalSection)
 141 {
 142     return RtlLeaveCriticalSection(CriticalSection );
 143 }
 144
 145 PVOID
 146 NTAPI
 147 RtlpAllocateMemory(UINT Bytes,
 148                    ULONG Tag)
 149 {
 150     UNREFERENCED_PARAMETER(Tag);
 151
 152     return RtlAllocateHeap(RtlGetProcessHeap(),
 153                            0,
 154                            Bytes);
 155 }
 156
 157
 158 VOID
 159 NTAPI
 160 RtlpFreeMemory(PVOID Mem,
 161                ULONG Tag)
 162 {
 163     UNREFERENCED_PARAMETER(Tag);
 164
 165     RtlFreeHeap(RtlGetProcessHeap(),
 166                 0,
 167                 Mem);
 168 }
 169
 170
 171 #if DBG
 172 VOID FASTCALL
 173 CHECK_PAGED_CODE_RTL(char *file, int line)
 174 {
 175   /* meaningless in user mode */
 176 }
 177 #endif
 178
 179 BOOLEAN
 180 NTAPI
 181 RtlpHandleDpcStackException(IN PEXCEPTION_REGISTRATION_RECORD RegistrationFrame,
 182                             IN ULONG_PTR RegistrationFrameEnd,
 183                             IN OUT PULONG_PTR StackLow,
 184                             IN OUT PULONG_PTR StackHigh)
 185 {
 186     /* There's no such thing as a DPC stack in user-mode */
 187     return FALSE;
 188 }
 189
 190 VOID
 191 NTAPI
 192 RtlpCheckLogException(IN PEXCEPTION_RECORD ExceptionRecord,
 193                       IN PCONTEXT ContextRecord,
 194                       IN PVOID ContextData,
 195                       IN ULONG Size)
 196 {
 197     /* Exception logging is not done in user-mode */
 198 }
 199
 200 BOOLEAN
 201 NTAPI
 202 RtlpCaptureStackLimits(IN ULONG_PTR Ebp,
 203                        IN ULONG_PTR *StackBegin,
 204                        IN ULONG_PTR *StackEnd)
 205 {
 206     /* FIXME: Verify */
 207     *StackBegin = (ULONG_PTR)NtCurrentTeb()->NtTib.StackLimit;
 208     *StackEnd = (ULONG_PTR)NtCurrentTeb()->NtTib.StackBase;
 209     return TRUE;
 210 }
 211
 212 #ifdef _AMD64_
 213 VOID
 214 NTAPI
 215 RtlpGetStackLimits(
 216     OUT PULONG_PTR LowLimit,
 217     OUT PULONG_PTR HighLimit)
 218 {
 219     *LowLimit = (ULONG_PTR)NtCurrentTeb()->NtTib.StackLimit;
 220     *HighLimit = (ULONG_PTR)NtCurrentTeb()->NtTib.StackBase;
 221     return;
 222 }
 223 #endif
 224
 225 BOOLEAN
 226 NTAPI
 227 RtlIsThreadWithinLoaderCallout(VOID)
 228 {
 229     return LdrpTopLevelDllBeingLoadedTeb == NtCurrentTeb();
 230 }
 231
 232 /* RTL Atom Tables ************************************************************/
 233
 234 typedef struct _RTL_ATOM_HANDLE
 235 {
 236    RTL_HANDLE_TABLE_ENTRY Handle;
 237    PRTL_ATOM_TABLE_ENTRY AtomEntry;
 238 } RTL_ATOM_HANDLE, *PRTL_ATOM_HANDLE;
 239
 240 NTSTATUS
 241 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 242 {
 243    RtlInitializeCriticalSection(&AtomTable->CriticalSection);
 244    return STATUS_SUCCESS;
 245 }
 246
 247
 248 VOID
 249 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 250 {
 251    RtlDeleteCriticalSection(&AtomTable->CriticalSection);
 252 }
 253
 254
 255 BOOLEAN
 256 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 257 {
 258    RtlEnterCriticalSection(&AtomTable->CriticalSection);
 259    return TRUE;
 260 }
 261
 262
 263 VOID
 264 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 265 {
 266    RtlLeaveCriticalSection(&AtomTable->CriticalSection);
 267 }
 268
 269
 270 /* handle functions */
 271
 272 BOOLEAN
 273 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 274 {
 275    RtlInitializeHandleTable(0xCFFF,
 276                             sizeof(RTL_ATOM_HANDLE),
 277                             &AtomTable->RtlHandleTable);
 278
 279    return TRUE;
 280 }
 281
 282 VOID
 283 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 284 {
 285    RtlDestroyHandleTable(&AtomTable->RtlHandleTable);
 286 }
 287
 288 PRTL_ATOM_TABLE
 289 RtlpAllocAtomTable(ULONG Size)
 290 {
 291    return (PRTL_ATOM_TABLE)RtlAllocateHeap(RtlGetProcessHeap(),
 292                                            HEAP_ZERO_MEMORY,
 293                                            Size);
 294 }
 295
 296 VOID
 297 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 298 {
 299    RtlFreeHeap(RtlGetProcessHeap(),
 300                0,
 301                AtomTable);
 302 }
 303
 304 PRTL_ATOM_TABLE_ENTRY
 305 RtlpAllocAtomTableEntry(ULONG Size)
 306 {
 307    return (PRTL_ATOM_TABLE_ENTRY)RtlAllocateHeap(RtlGetProcessHeap(),
 308                                                  HEAP_ZERO_MEMORY,
 309                                                  Size);
 310 }
 311
 312 VOID
 313 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 314 {
 315    RtlFreeHeap(RtlGetProcessHeap(),
 316                0,
 317                Entry);
 318 }
 319
 320 VOID
 321 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 322 {
 323    PRTL_HANDLE_TABLE_ENTRY RtlHandleEntry;
 324
 325    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 326                              (ULONG)Entry->HandleIndex,
 327                              &RtlHandleEntry))
 328    {
 329       RtlFreeHandle(&AtomTable->RtlHandleTable,
 330                     RtlHandleEntry);
 331    }
 332 }
 333
 334 BOOLEAN
 335 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 336 {
 337    ULONG HandleIndex;
 338    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 339
 340    RtlHandle = RtlAllocateHandle(&AtomTable->RtlHandleTable,
 341                                  &HandleIndex);
 342    if (RtlHandle != NULL)
 343    {
 344       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 345
 346       /* FIXME - Handle Indexes >= 0xC000 ?! */
 347       if (HandleIndex < 0xC000)
 348       {
 349          Entry->HandleIndex = (USHORT)HandleIndex;
 350          Entry->Atom = 0xC000 + (USHORT)HandleIndex;
 351
 352          AtomHandle->AtomEntry = Entry;
 353          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 354
 355          return TRUE;
 356       }
 357       else
 358       {
 359          /* set the valid flag, otherwise RtlFreeHandle will fail! */
 360          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 361
 362          RtlFreeHandle(&AtomTable->RtlHandleTable,
 363                        RtlHandle);
 364       }
 365    }
 366
 367    return FALSE;
 368 }
 369
 370 PRTL_ATOM_TABLE_ENTRY
 371 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 372 {
 373    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 374
 375    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 376                              Index,
 377                              &RtlHandle))
 378    {
 379       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 380
 381       return AtomHandle->AtomEntry;
 382    }
 383
 384    return NULL;
 385 }
 386
 387
 388 /*
 389  * Ldr Resource support code
 390  */
 391
 392 IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( IMAGE_RESOURCE_DIRECTORY *dir,
 393                                               LPCWSTR name, void *root,
 394                                               int want_dir );
 395 IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( IMAGE_RESOURCE_DIRECTORY *dir,
 396                                             WORD id, void *root, int want_dir );
 397 IMAGE_RESOURCE_DIRECTORY *find_first_entry( IMAGE_RESOURCE_DIRECTORY *dir,
 398                                             void *root, int want_dir );
 399 int push_language( USHORT *list, ULONG pos, WORD lang );
 400
 401 /**********************************************************************
 402  *  find_entry
 403  *
 404  * Find a resource entry
 405  */
 406 NTSTATUS find_entry( PVOID BaseAddress, LDR_RESOURCE_INFO *info,
 407                      ULONG level, void **ret, int want_dir )
 408 {
 409     ULONG size;
 410     void *root;
 411     IMAGE_RESOURCE_DIRECTORY *resdirptr;
 412     USHORT list[9];  /* list of languages to try */
 413     int i, pos = 0;
 414     LCID user_lcid, system_lcid;
 415
 416     root = RtlImageDirectoryEntryToData( BaseAddress, TRUE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &size );
 417     if (!root) return STATUS_RESOURCE_DATA_NOT_FOUND;
 418     resdirptr = root;
 419
 420     if (!level--) goto done;
 421     if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Type, root, want_dir || level )))
 422         return STATUS_RESOURCE_TYPE_NOT_FOUND;
 423     if (!level--) return STATUS_SUCCESS;
 424
 425     resdirptr = *ret;
 426     if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Name, root, want_dir || level )))
 427         return STATUS_RESOURCE_NAME_NOT_FOUND;
 428     if (!level--) return STATUS_SUCCESS;
 429     if (level) return STATUS_INVALID_PARAMETER;  /* level > 3 */
 430
 431     /* 1. specified language */
 432     pos = push_language( list, pos, info->Language );
 433
 434     /* 2. specified language with neutral sublanguage */
 435     pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(info->Language), SUBLANG_NEUTRAL ) );
 436
 437     /* 3. neutral language with neutral sublanguage */
 438     pos = push_language( list, pos, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
 439
 440     /* if no explicitly specified language, try some defaults */
 441     if (PRIMARYLANGID(info->Language) == LANG_NEUTRAL)
 442     {
 443         /* user defaults, unless SYS_DEFAULT sublanguage specified  */
 444         if (SUBLANGID(info->Language) != SUBLANG_SYS_DEFAULT)
 445         {
 446             /* 4. current thread locale language */
 447             pos = push_language( list, pos, LANGIDFROMLCID(NtCurrentTeb()->CurrentLocale) );
 448
 449             if (NT_SUCCESS(NtQueryDefaultLocale(TRUE, &user_lcid)))
 450             {
 451                 /* 5. user locale language */
 452                 pos = push_language( list, pos, LANGIDFROMLCID(user_lcid) );
 453
 454                 /* 6. user locale language with neutral sublanguage  */
 455                 pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(user_lcid), SUBLANG_NEUTRAL ) );
 456             }
 457         }
 458
 459         /* now system defaults */
 460
 461         if (NT_SUCCESS(NtQueryDefaultLocale(FALSE, &system_lcid)))
 462         {
 463             /* 7. system locale language */
 464             pos = push_language( list, pos, LANGIDFROMLCID( system_lcid ) );
 465
 466             /* 8. system locale language with neutral sublanguage */
 467             pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(system_lcid), SUBLANG_NEUTRAL ) );
 468         }
 469
 470         /* 9. English */
 471         pos = push_language( list, pos, MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT ) );
 472     }
 473
 474     resdirptr = *ret;
 475     for (i = 0; i < pos; i++)
 476         if ((*ret = find_entry_by_id( resdirptr, list[i], root, want_dir ))) return STATUS_SUCCESS;
 477
 478     /* if no explicitly specified language, return the first entry */
 479     if (PRIMARYLANGID(info->Language) == LANG_NEUTRAL)
 480     {
 481         if ((*ret = find_first_entry( resdirptr, root, want_dir ))) return STATUS_SUCCESS;
 482     }
 483     return STATUS_RESOURCE_LANG_NOT_FOUND;
 484
 485 done:
 486     *ret = resdirptr;
 487     return STATUS_SUCCESS;
 488 }