reactos/include/ntos/rtl.h

   1 /* $Id: rtl.h,v 1.1 2002/09/07 15:12:21 chorns Exp $
   2  *
   3  */
   4
   5 #ifndef __DDK_RTL_H
   6 #define __DDK_RTL_H
   7
   8 /*
   9 VOID
  10 InitializeUnicodeString (
  11         PUNICODE_STRING DestinationString,
  12         USHORT          Lenght,
  13         USHORT          MaximumLength,
  14         PCWSTR          Buffer
  15         );
  16
  17  Initialize an UNICODE_STRING from its fields. Use when you know the values of
  18  all the fields in advance
  19
  20  */
  21
  22 #define InitializeUnicodeString(__PDEST_STRING__,__LENGTH__,__MAXLENGTH__,__BUFFER__) \
  23 { \
  24  (__PDEST_STRING__)->Length = (__LENGTH__); \
  25  (__PDEST_STRING__)->MaximumLength = (__MAXLENGTH__); \
  26  (__PDEST_STRING__)->Buffer = (__BUFFER__); \
  27 }
  28
  29 /*
  30 VOID
  31 RtlInitUnicodeStringFromLiteral (
  32         PUNICODE_STRING DestinationString,
  33         PCWSTR          SourceString
  34         );
  35
  36  Initialize an UNICODE_STRING from a wide string literal. WARNING: use only with
  37  string literals and statically initialized arrays, it will calculate the wrong
  38  length otherwise
  39
  40  */
  41
  42 #define RtlInitUnicodeStringFromLiteral(__PDEST_STRING__,__SOURCE_STRING__) \
  43  InitializeUnicodeString( \
  44   (__PDEST_STRING__), \
  45   sizeof(__SOURCE_STRING__) - sizeof(WCHAR), \
  46   sizeof(__SOURCE_STRING__), \
  47   (__SOURCE_STRING__) \
  48  )
  49
  50 /*
  51  Static initializer for UNICODE_STRING variables. Usage:
  52
  53  UNICODE_STRING wstr = UNICODE_STRING_INITIALIZER(L"string");
  54
  55 */
  56
  57 #define UNICODE_STRING_INITIALIZER(__SOURCE_STRING__) \
  58 { \
  59  sizeof((__SOURCE_STRING__)) - sizeof(WCHAR), \
  60  sizeof((__SOURCE_STRING__)), \
  61  (__SOURCE_STRING__) \
  62 }
  63
  64 /*
  65  Initializer for empty UNICODE_STRING variables. Usage:
  66
  67  UNICODE_STRING wstr = EMPTY_UNICODE_STRING;
  68
  69 */
  70 #define EMPTY_UNICODE_STRING {0, 0, NULL}
  71
  72 typedef struct _INITIAL_TEB
  73 {
  74   ULONG StackCommit;
  75   ULONG StackReserve;
  76   PVOID StackBase;
  77   PVOID StackLimit;
  78   PVOID StackAllocate;
  79 } INITIAL_TEB, *PINITIAL_TEB;
  80
  81 typedef struct _RTL_HEAP_DEFINITION
  82 {
  83   ULONG Length;
  84   ULONG Unknown[11];
  85 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
  86
  87 typedef struct _RTL_ATOM_TABLE
  88 {
  89   ULONG TableSize;
  90   ULONG NumberOfAtoms;
  91   PVOID Lock;           /* fast mutex (kernel mode)/ critical section (user mode) */
  92   PVOID HandleTable;
  93   LIST_ENTRY Slot[0];
  94 } RTL_ATOM_TABLE, *PRTL_ATOM_TABLE;
  95
  96 typedef struct _LB_RANGE
  97 {
  98   UCHAR upper;
  99   UCHAR lower;
 100 } LB_RANGE;
 101
 102 typedef struct _RTL_NLS_DATA
 103 {
 104   USHORT   CodePage;
 105   USHORT   MaxCharacterSize;  // SBCS = 1, DBCS = 2
 106   WCHAR    DefaultCharacter;
 107   WCHAR    char1;
 108   WCHAR    char2;
 109   WCHAR    char3;
 110   USHORT   DbcsFlag;
 111   LB_RANGE LeadByteRange[6];
 112   USHORT   reserved;
 113   PWCHAR   MultiByteToUnicode;
 114   PCHAR    UnicodeToMultiByte;
 115   PWCHAR   DosMultiByteToUnicode;
 116   PCHAR    DbcsTags;
 117 } RTL_NLS_DATA, *PRTL_NLS_DATA;
 118
 119 typedef struct _RTL_NLS_TABLE
 120 {
 121   RTL_NLS_DATA OemInfo;
 122   RTL_NLS_DATA AnsiInfo;
 123   PWCHAR UpcaseTable;
 124   PWCHAR DowncaseTable;
 125 } RTL_NLS_TABLE, *PRTL_NLS_TABLE;
 126
 127
 128 typedef struct _RTL_GENERIC_TABLE
 129 {
 130   PVOID RootElement;
 131   ULONG Unknown2;
 132   ULONG Unknown3;
 133   ULONG Unknown4;
 134   ULONG Unknown5;
 135   ULONG ElementCount;
 136   PVOID CompareRoutine;
 137   PVOID AllocateRoutine;
 138   PVOID FreeRoutine;
 139   ULONG UserParameter;
 140 } RTL_GENERIC_TABLE, *PRTL_GENERIC_TABLE;
 141
 142
 143 typedef struct _RTL_MESSAGE_RESOURCE_ENTRY
 144 {
 145   USHORT Length;
 146   USHORT Flags;
 147   UCHAR Text[1];
 148 } RTL_MESSAGE_RESOURCE_ENTRY, *PRTL_MESSAGE_RESOURCE_ENTRY;
 149
 150 typedef struct _RTL_MESSAGE_RESOURCE_BLOCK
 151 {
 152   ULONG LowId;
 153   ULONG HighId;
 154   ULONG OffsetToEntries;
 155 } RTL_MESSAGE_RESOURCE_BLOCK, *PRTL_MESSAGE_RESOURCE_BLOCK;
 156
 157 typedef struct _RTL_MESSAGE_RESOURCE_DATA
 158 {
 159   ULONG NumberOfBlocks;
 160   RTL_MESSAGE_RESOURCE_BLOCK Blocks[1];
 161 } RTL_MESSAGE_RESOURCE_DATA, *PRTL_MESSAGE_RESOURCE_DATA;
 162
 163 /*
 164  * PURPOSE: Used with RtlCheckRegistryKey, RtlCreateRegistryKey,
 165  * RtlDeleteRegistryKey
 166  */
 167 #define RTL_REGISTRY_ABSOLUTE   0
 168 #define RTL_REGISTRY_SERVICES   1
 169 #define RTL_REGISTRY_CONTROL    2
 170 #define RTL_REGISTRY_WINDOWS_NT 3
 171 #define RTL_REGISTRY_DEVICEMAP  4
 172 #define RTL_REGISTRY_USER       5
 173 #define RTL_REGISTRY_ENUM       6   // ReactOS specific: Used internally in kernel only
 174 #define RTL_REGISTRY_MAXIMUM    7
 175
 176 #define RTL_REGISTRY_HANDLE     0x40000000
 177 #define RTL_REGISTRY_OPTIONAL   0x80000000
 178
 179
 180 #define SHORT_SIZE      (sizeof(USHORT))
 181 #define SHORT_MASK      (SHORT_SIZE-1)
 182 #define LONG_SIZE       (sizeof(ULONG))
 183 #define LONG_MASK       (LONG_SIZE-1)
 184 #define LOWBYTE_MASK    0x00FF
 185
 186 #define FIRSTBYTE(Value)        ((Value) & LOWBYTE_MASK)
 187 #define SECONDBYTE(Value)       (((Value) >> 8) & LOWBYTE_MASK)
 188 #define THIRDBYTE(Value)        (((Value) >> 16) & LOWBYTE_MASK)
 189 #define FOURTHBYTE(Value)       (((Value) >> 24) & LOWBYTE_MASK)
 190
 191 /* FIXME: reverse byte-order on big-endian machines (e.g. MIPS) */
 192 #define SHORT_LEAST_SIGNIFICANT_BIT     0
 193 #define SHORT_MOST_SIGNIFICANT_BIT      1
 194
 195 #define LONG_LEAST_SIGNIFICANT_BIT      0
 196 #define LONG_3RD_MOST_SIGNIFICANT_BIT   1
 197 #define LONG_2RD_MOST_SIGNIFICANT_BIT   2
 198 #define LONG_MOST_SIGNIFICANT_BIT       3
 199
 200
 201
 202 #if defined(_NTOSKRNL_) || defined(__NTDLL__)
 203 #define NLS_MB_CODE_PAGE_TAG     NlsMbCodePageTag
 204 #define NLS_MB_OEM_CODE_PAGE_TAG NlsMbOemCodePageTag
 205 #else
 206 #define NLS_MB_CODE_PAGE_TAG     (*NlsMbCodePageTag)
 207 #define NLS_MB_OEM_CODE_PAGE_TAG (*NlsMbOemCodePageTag)
 208 #endif /* _NTOSKRNL_ || __NTDLL__ */
 209
 210 extern BOOLEAN NLS_MB_CODE_PAGE_TAG;
 211 extern BOOLEAN NLS_MB_OEM_CODE_PAGE_TAG;
 212
 213
 214 /*
 215  * NOTE: ReactOS extensions
 216  */
 217 #define RtlMin(X,Y) (((X) < (Y))? (X) : (Y))
 218 #define RtlMax(X,Y) (((X) > (Y))? (X) : (Y))
 219 #define RtlMin3(X,Y,Z) (((X) < (Y)) ? RtlMin(X,Z) : RtlMin(Y,Z))
 220 #define RtlMax3(X,Y,Z) (((X) > (Y)) ? RtlMax(X,Z) : RtlMax(Y,Z))
 221
 222 #if 0
 223 /*
 224  * VOID
 225  * InitializeObjectAttributes (
 226  *      POBJECT_ATTRIBUTES      InitializedAttributes,
 227  *      PUNICODE_STRING         ObjectName,
 228  *      ULONG                   Attributes,
 229  *      HANDLE                  RootDirectory,
 230  *      PSECURITY_DESCRIPTOR    SecurityDescriptor
 231  *      );
 232  *
 233  * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
 234  * subsequent call to ZwCreateXXX or ZwOpenXXX
 235  * ARGUMENTS:
 236  *        InitializedAttributes (OUT) = Caller supplied storage for the
 237  *                                      object attributes
 238  *        ObjectName = Full path name for object
 239  *        Attributes = Attributes for the object
 240  *        RootDirectory = Where the object should be placed or NULL
 241  *        SecurityDescriptor = Ignored
 242  */
 243 #define InitializeObjectAttributes(p,n,a,r,s) \
 244 { \
 245         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
 246         (p)->ObjectName = n; \
 247         (p)->Attributes = a; \
 248         (p)->RootDirectory = r; \
 249         (p)->SecurityDescriptor = s; \
 250         (p)->SecurityQualityOfService = NULL; \
 251 }
 252 #endif
 253
 254 /*
 255  * An ReactOS extension
 256  */
 257 static
 258 inline
 259 PSINGLE_LIST_ENTRY
 260  PopEntrySList(
 261         PSLIST_HEADER   ListHead
 262         )
 263 {
 264         PSINGLE_LIST_ENTRY ListEntry;
 265
 266         ListEntry = ListHead->Next.Next;
 267         if (ListEntry!=NULL)
 268         {
 269                 ListHead->Next.Next = ListEntry->Next;
 270     ListHead->Depth++;
 271     ListHead->Sequence++;
 272   }
 273         return ListEntry;
 274 }
 275
 276
 277 /*
 278  * An ReactOS extension
 279  */
 280 static
 281 inline
 282 VOID
 283 PushEntrySList (
 284         PSLIST_HEADER   ListHead,
 285         PSINGLE_LIST_ENTRY      Entry
 286         )
 287 {
 288         Entry->Next = ListHead->Next.Next;
 289         ListHead->Next.Next = Entry;
 290   ListHead->Depth++;
 291   ListHead->Sequence++;
 292 }
 293
 294 NTSTATUS
 295 STDCALL
 296 RtlAddAtomToAtomTable (
 297         IN      PRTL_ATOM_TABLE AtomTable,
 298         IN      PWSTR           AtomName,
 299         OUT     PRTL_ATOM       Atom
 300         );
 301
 302 PVOID STDCALL
 303 RtlAllocateHeap (
 304         HANDLE  Heap,
 305         ULONG   Flags,
 306         ULONG   Size
 307         );
 308
 309 WCHAR
 310 STDCALL
 311 RtlAnsiCharToUnicodeChar (
 312         CHAR    AnsiChar
 313         );
 314
 315 ULONG
 316 STDCALL
 317 RtlAnsiStringToUnicodeSize (
 318         PANSI_STRING    AnsiString
 319         );
 320
 321 NTSTATUS
 322 STDCALL
 323 RtlAnsiStringToUnicodeString (
 324         PUNICODE_STRING DestinationString,
 325         PANSI_STRING    SourceString,
 326         BOOLEAN         AllocateDestinationString
 327         );
 328
 329 NTSTATUS
 330 STDCALL
 331 RtlAppendAsciizToString(
 332         PSTRING Destination,
 333         PCSZ    Source
 334         );
 335
 336 NTSTATUS
 337 STDCALL
 338 RtlAppendStringToString (
 339         PSTRING Destination,
 340         PSTRING Source
 341         );
 342
 343 NTSTATUS
 344 STDCALL
 345 RtlAppendUnicodeStringToString (
 346         PUNICODE_STRING Destination,
 347         PUNICODE_STRING Source
 348         );
 349
 350 BOOLEAN
 351 STDCALL
 352 RtlAreBitsClear (
 353         PRTL_BITMAP     BitMapHeader,
 354         ULONG           StartingIndex,
 355         ULONG           Length
 356         );
 357
 358 BOOLEAN
 359 STDCALL
 360 RtlAreBitsSet (
 361         PRTL_BITMAP     BitMapHeader,
 362         ULONG           StartingIndex,
 363         ULONG           Length
 364         );
 365
 366 VOID
 367 STDCALL
 368 RtlAssert (
 369         PVOID FailedAssertion,
 370         PVOID FileName,
 371         ULONG LineNumber,
 372         PCHAR Message
 373         );
 374
 375 NTSTATUS
 376 STDCALL
 377 RtlCharToInteger (
 378         PCSZ    String,
 379         ULONG   Base,
 380         PULONG  Value
 381         );
 382
 383 NTSTATUS
 384 STDCALL
 385 RtlCheckRegistryKey (
 386         ULONG   RelativeTo,
 387         PWSTR   Path
 388         );
 389
 390 VOID
 391 STDCALL
 392 RtlClearAllBits (
 393         IN      PRTL_BITMAP     BitMapHeader
 394         );
 395
 396 VOID
 397 STDCALL
 398 RtlClearBits (
 399         IN      PRTL_BITMAP     BitMapHeader,
 400         IN      ULONG           StartingIndex,
 401         IN      ULONG           NumberToClear
 402         );
 403
 404 DWORD
 405 STDCALL
 406 RtlCompactHeap (
 407         HANDLE  hheap,
 408         DWORD   flags
 409         );
 410
 411 LONG
 412 STDCALL
 413 RtlCompareString (
 414         PSTRING String1,
 415         PSTRING String2,
 416         BOOLEAN CaseInsensitive
 417         );
 418
 419 LONG
 420 STDCALL
 421 RtlCompareUnicodeString (
 422         PUNICODE_STRING String1,
 423         PUNICODE_STRING String2,
 424         BOOLEAN         BaseInsensitive
 425         );
 426
 427 LARGE_INTEGER
 428 STDCALL
 429 RtlConvertLongToLargeInteger (
 430         IN      LONG    SignedInteger
 431         );
 432
 433 NTSTATUS
 434 STDCALL
 435 RtlConvertSidToUnicodeString (
 436         IN OUT  PUNICODE_STRING String,
 437         IN      PSID            Sid,
 438         IN      BOOLEAN         AllocateString
 439         );
 440
 441 LARGE_INTEGER
 442 STDCALL
 443 RtlConvertUlongToLargeInteger (
 444         IN      ULONG   UnsignedInteger
 445         );
 446
 447 #undef RtlCopyBytes
 448
 449 VOID
 450 RtlCopyBytes (
 451         PVOID           Destination,
 452         CONST VOID      * Source,
 453         ULONG           Length
 454         );
 455
 456 #undef RtlCopyMemory
 457
 458 #define RtlCopyMemory(Destination,Source,Length) \
 459         memcpy((Destination),(Source),(Length))
 460
 461 #define RtlCopyBytes RtlCopyMemory
 462
 463 VOID STDCALL
 464 RtlCopyLuid(IN PLUID LuidDest,
 465             IN PLUID LuidSrc);
 466
 467 VOID
 468 STDCALL
 469 RtlCopyString (
 470         PSTRING DestinationString,
 471         PSTRING SourceString
 472         );
 473
 474 VOID
 475 STDCALL
 476 RtlCopyUnicodeString (
 477         PUNICODE_STRING DestinationString,
 478         PUNICODE_STRING SourceString
 479         );
 480
 481 NTSTATUS
 482 STDCALL
 483 RtlCreateAtomTable (
 484         IN      ULONG TableSize,
 485         IN OUT  PRTL_ATOM_TABLE *AtomTable
 486         );
 487
 488 HANDLE
 489 STDCALL
 490 RtlCreateHeap (
 491         ULONG                   Flags,
 492         PVOID                   BaseAddress,
 493         ULONG                   SizeToReserve,
 494         ULONG                   SizeToCommit,
 495         PVOID                   Unknown,
 496         PRTL_HEAP_DEFINITION    Definition
 497         );
 498
 499 NTSTATUS
 500 STDCALL
 501 RtlCreateRegistryKey (
 502         ULONG   RelativeTo,
 503         PWSTR   Path
 504         );
 505
 506 NTSTATUS
 507 STDCALL
 508 RtlCreateSecurityDescriptor (
 509         PSECURITY_DESCRIPTOR    SecurityDescriptor,
 510         ULONG                   Revision
 511         );
 512
 513 BOOLEAN
 514 STDCALL
 515 RtlCreateUnicodeString (
 516         OUT     PUNICODE_STRING Destination,
 517         IN      PWSTR           Source
 518         );
 519
 520 BOOLEAN
 521 STDCALL
 522 RtlCreateUnicodeStringFromAsciiz (
 523         OUT     PUNICODE_STRING Destination,
 524         IN      PCSZ            Source
 525         );
 526
 527 NTSTATUS
 528 STDCALL
 529 RtlCustomCPToUnicodeN (
 530         PRTL_NLS_DATA   NlsData,
 531         PWCHAR          UnicodeString,
 532         ULONG           UnicodeSize,
 533         PULONG          ResultSize,
 534         PCHAR           CustomString,
 535         ULONG           CustomSize
 536         );
 537
 538 NTSTATUS
 539 STDCALL
 540 RtlDeleteAtomFromAtomTable (
 541         IN      PRTL_ATOM_TABLE AtomTable,
 542         IN      RTL_ATOM        Atom
 543         );
 544
 545 NTSTATUS
 546 STDCALL
 547 RtlDestroyAtomTable (
 548         IN      PRTL_ATOM_TABLE AtomTable
 549         );
 550
 551 BOOL
 552 STDCALL
 553 RtlDestroyHeap (
 554         HANDLE  hheap
 555         );
 556
 557 NTSTATUS
 558 STDCALL
 559 RtlDowncaseUnicodeString (
 560         IN OUT PUNICODE_STRING  DestinationString,
 561         IN PUNICODE_STRING      SourceString,
 562         IN BOOLEAN              AllocateDestinationString
 563         );
 564
 565 NTSTATUS
 566 STDCALL
 567 RtlEmptyAtomTable (
 568         IN      PRTL_ATOM_TABLE AtomTable,
 569         IN      BOOLEAN         DeletePinned
 570         );
 571
 572 LARGE_INTEGER
 573 STDCALL
 574 RtlEnlargedIntegerMultiply (
 575         LONG    Multiplicand,
 576         LONG    Multiplier
 577         );
 578
 579 ULONG
 580 STDCALL
 581 RtlEnlargedUnsignedDivide (
 582         ULARGE_INTEGER  Dividend,
 583         ULONG           Divisor,
 584         PULONG          Remainder
 585         );
 586
 587 LARGE_INTEGER
 588 STDCALL
 589 RtlEnlargedUnsignedMultiply (
 590         ULONG   Multiplicand,
 591         ULONG   Multiplier
 592         );
 593 #if 0
 594 BOOLEAN STDCALL
 595 RtlEqualLuid(IN PLUID Luid1,
 596              IN PLUID Luid2);
 597 #endif
 598
 599 BOOLEAN
 600 STDCALL
 601 RtlEqualString (
 602         PSTRING String1,
 603         PSTRING String2,
 604         BOOLEAN CaseInSensitive
 605         );
 606
 607 LARGE_INTEGER
 608 STDCALL
 609 RtlExtendedIntegerMultiply (
 610         LARGE_INTEGER   Multiplicand,
 611         LONG            Multiplier
 612         );
 613
 614 LARGE_INTEGER
 615 STDCALL
 616 RtlExtendedLargeIntegerDivide (
 617         LARGE_INTEGER   Dividend,
 618         ULONG           Divisor,
 619         PULONG          Remainder
 620         );
 621
 622 LARGE_INTEGER
 623 STDCALL
 624 RtlExtendedMagicDivide (
 625         LARGE_INTEGER   Dividend,
 626         LARGE_INTEGER   MagicDivisor,
 627         CCHAR           ShiftCount
 628         );
 629
 630 #undef RtlFillMemory
 631
 632 VOID
 633 STDCALL
 634 RtlFillMemory (
 635         PVOID   Destination,
 636         ULONG   Length,
 637         UCHAR   Fill
 638         );
 639
 640 VOID
 641 STDCALL
 642 RtlFillMemoryUlong (
 643         PVOID   Destination,
 644         ULONG   Length,
 645         ULONG   Fill
 646         );
 647
 648 ULONG
 649 STDCALL
 650 RtlFindClearBits (
 651         PRTL_BITMAP     BitMapHeader,
 652         ULONG           NumberToFind,
 653         ULONG           HintIndex
 654         );
 655
 656 ULONG
 657 STDCALL
 658 RtlFindClearBitsAndSet (
 659         PRTL_BITMAP     BitMapHeader,
 660         ULONG           NumberToFind,
 661         ULONG           HintIndex
 662         );
 663
 664 ULONG
 665 STDCALL
 666 RtlFindFirstRunClear (
 667         PRTL_BITMAP     BitMapHeader,
 668         PULONG          StartingIndex
 669         );
 670
 671 ULONG
 672 STDCALL
 673 RtlFindFirstRunSet (
 674         PRTL_BITMAP     BitMapHeader,
 675         PULONG          StartingIndex
 676         );
 677
 678 ULONG
 679 STDCALL
 680 RtlFindLongestRunClear (
 681         PRTL_BITMAP     BitMapHeader,
 682         PULONG          StartingIndex
 683         );
 684
 685 ULONG
 686 STDCALL
 687 RtlFindLongestRunSet (
 688         PRTL_BITMAP     BitMapHeader,
 689         PULONG          StartingIndex
 690         );
 691
 692 NTSTATUS
 693 STDCALL
 694 RtlFindMessage (
 695         IN      PVOID                           BaseAddress,
 696         IN      ULONG                           Type,
 697         IN      ULONG                           Language,
 698         IN      ULONG                           MessageId,
 699         OUT     PRTL_MESSAGE_RESOURCE_ENTRY     *MessageResourceEntry
 700         );
 701
 702 ULONG
 703 STDCALL
 704 RtlFindSetBits (
 705         PRTL_BITMAP     BitMapHeader,
 706         ULONG           NumberToFind,
 707         ULONG           HintIndex
 708         );
 709
 710 ULONG
 711 STDCALL
 712 RtlFindSetBitsAndClear (
 713         PRTL_BITMAP     BitMapHeader,
 714         ULONG           NumberToFind,
 715         ULONG           HintIndex
 716         );
 717
 718 NTSTATUS
 719 STDCALL
 720 RtlFormatCurrentUserKeyPath (
 721         IN OUT  PUNICODE_STRING KeyPath
 722         );
 723
 724 VOID
 725 STDCALL
 726 RtlFreeAnsiString (
 727         PANSI_STRING    AnsiString
 728         );
 729
 730 BOOLEAN
 731 STDCALL
 732 RtlFreeHeap (
 733         HANDLE  Heap,
 734         ULONG   Flags,
 735         PVOID   Address
 736         );
 737
 738 VOID
 739 STDCALL
 740 RtlFreeOemString (
 741         POEM_STRING     OemString
 742         );
 743
 744 VOID
 745 STDCALL
 746 RtlFreeUnicodeString (
 747         PUNICODE_STRING UnicodeString
 748         );
 749
 750 VOID STDCALL
 751 RtlGenerate8dot3Name(IN PUNICODE_STRING Name,
 752                      IN BOOLEAN AllowExtendedCharacters,
 753                      IN OUT PGENERATE_NAME_CONTEXT Context,
 754                      OUT PUNICODE_STRING Name8dot3);
 755
 756 VOID
 757 STDCALL
 758 RtlGetDefaultCodePage (
 759         PUSHORT AnsiCodePage,
 760         PUSHORT OemCodePage
 761         );
 762
 763 /*
 764  * HANDLE
 765  * STDCALL
 766  * RtlGetProcessHeap (
 767  *      VOID
 768  *      );
 769  */
 770 #define RtlGetProcessHeap() (NtCurrentPeb()->ProcessHeap)
 771
 772
 773 PVOID
 774 STDCALL
 775 RtlImageDirectoryEntryToData (
 776         PVOID   BaseAddress,
 777         BOOLEAN bFlag,
 778         ULONG   Directory,
 779         PULONG  Size
 780         );
 781
 782 PIMAGE_NT_HEADERS
 783 STDCALL
 784 RtlImageNtHeader (
 785         PVOID   BaseAddress
 786         );
 787
 788 PIMAGE_SECTION_HEADER
 789 STDCALL
 790 RtlImageRvaToSection (
 791         PIMAGE_NT_HEADERS       NtHeader,
 792         PVOID                   BaseAddress,
 793         ULONG                   Rva
 794         );
 795
 796 ULONG
 797 STDCALL
 798 RtlImageRvaToVa (
 799         PIMAGE_NT_HEADERS       NtHeader,
 800         PVOID                   BaseAddress,
 801         ULONG                   Rva,
 802         PIMAGE_SECTION_HEADER   *SectionHeader
 803         );
 804
 805 VOID
 806 STDCALL
 807 RtlInitAnsiString (
 808         PANSI_STRING    DestinationString,
 809         PCSZ            SourceString
 810         );
 811
 812 VOID
 813 STDCALL
 814 RtlInitString (
 815         PSTRING DestinationString,
 816         PCSZ    SourceString
 817         );
 818
 819 VOID
 820 STDCALL
 821 RtlInitUnicodeString (
 822         PUNICODE_STRING DestinationString,
 823         PCWSTR          SourceString
 824         );
 825
 826 VOID
 827 STDCALL
 828 RtlInitializeBitMap (
 829         IN OUT  PRTL_BITMAP     BitMapHeader,
 830         IN      PULONG          BitMapBuffer,
 831         IN      ULONG           SizeOfBitMap
 832         );
 833
 834 NTSTATUS
 835 STDCALL
 836 RtlInitializeContext (
 837         IN      HANDLE                  ProcessHandle,
 838         IN      PCONTEXT                Context,
 839         IN      PVOID                   Parameter,
 840         IN      PTHREAD_START_ROUTINE   StartAddress,
 841         IN OUT  PINITIAL_TEB            InitialTeb
 842         );
 843
 844 VOID
 845 STDCALL
 846 RtlInitializeGenericTable (
 847         IN OUT  PRTL_GENERIC_TABLE      Table,
 848         IN      PVOID                   CompareRoutine,
 849         IN      PVOID                   AllocateRoutine,
 850         IN      PVOID                   FreeRoutine,
 851         IN      ULONG                   UserParameter
 852         );
 853
 854 PVOID
 855 STDCALL
 856 RtlInsertElementGenericTable (
 857         IN OUT  PRTL_GENERIC_TABLE      Table,
 858         IN      PVOID                   Element,
 859         IN      ULONG                   ElementSize,
 860         IN      ULONG                   Unknown4
 861         );
 862
 863 NTSTATUS
 864 STDCALL
 865 RtlIntegerToChar (
 866         IN      ULONG   Value,
 867         IN      ULONG   Base,
 868         IN      ULONG   Length,
 869         IN OUT  PCHAR   String
 870         );
 871
 872 NTSTATUS
 873 STDCALL
 874 RtlIntegerToUnicodeString (
 875         IN      ULONG           Value,
 876         IN      ULONG           Base,
 877         IN OUT  PUNICODE_STRING String
 878         );
 879
 880 BOOLEAN
 881 STDCALL
 882 RtlIsGenericTableEmpty (
 883         IN      PRTL_GENERIC_TABLE      Table
 884         );
 885
 886 BOOLEAN STDCALL
 887 RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName,
 888                        IN PANSI_STRING AnsiName,
 889                        OUT PBOOLEAN SpacesFound);
 890
 891 LARGE_INTEGER
 892 STDCALL
 893 RtlLargeIntegerAdd (
 894         LARGE_INTEGER   Addend1,
 895         LARGE_INTEGER   Addend2
 896         );
 897
 898 /*
 899  * VOID
 900  * RtlLargeIntegerAnd (
 901  *      PLARGE_INTEGER  Result,
 902  *      LARGE_INTEGER   Source,
 903  *      LARGE_INTEGER   Mask
 904  *      );
 905  */
 906 #define RtlLargeIntegerAnd(Result, Source, Mask) \
 907 { \
 908         Result.HighPart = Source.HighPart & Mask.HighPart; \
 909         Result.LowPart = Source.LowPart & Mask.LowPart; \
 910 }
 911
 912 LARGE_INTEGER
 913 STDCALL
 914 RtlLargeIntegerArithmeticShift (
 915         LARGE_INTEGER   LargeInteger,
 916         CCHAR   ShiftCount
 917         );
 918
 919 LARGE_INTEGER
 920 STDCALL
 921 RtlLargeIntegerDivide (
 922         LARGE_INTEGER   Dividend,
 923         LARGE_INTEGER   Divisor,
 924         PLARGE_INTEGER  Remainder
 925         );
 926
 927 /*
 928  * BOOLEAN
 929  * RtlLargeIntegerEqualTo (
 930  *      LARGE_INTEGER   Operand1,
 931  *      LARGE_INTEGER   Operand2
 932  *      );
 933  */
 934 #define RtlLargeIntegerEqualTo(X,Y) \
 935         (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
 936
 937 /*
 938  * BOOLEAN
 939  * RtlLargeIntegerEqualToZero (
 940  *      LARGE_INTEGER   Operand
 941  *      );
 942  */
 943 #define RtlLargeIntegerEqualToZero(X) \
 944         (!((X).LowPart | (X).HighPart))
 945
 946 /*
 947  * BOOLEAN
 948  * RtlLargeIntegerGreaterThan (
 949  *      LARGE_INTEGER   Operand1,
 950  *      LARGE_INTEGER   Operand2
 951  *      );
 952  */
 953 #define RtlLargeIntegerGreaterThan(X,Y) \
 954         ((((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
 955           ((X).HighPart > (Y).HighPart))
 956
 957 /*
 958  * BOOLEAN
 959  * RtlLargeIntegerGreaterThanOrEqualTo (
 960  *      LARGE_INTEGER   Operand1,
 961  *      LARGE_INTEGER   Operand2
 962  *      );
 963  */
 964 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) \
 965         ((((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
 966           ((X).HighPart > (Y).HighPart))
 967
 968 /*
 969  * BOOLEAN
 970  * RtlLargeIntegerGreaterThanOrEqualToZero (
 971  *      LARGE_INTEGER   Operand1
 972  *      );
 973  */
 974 #define RtlLargeIntegerGreaterOrEqualToZero(X) \
 975         ((X).HighPart >= 0)
 976
 977 /*
 978  * BOOLEAN
 979  * RtlLargeIntegerGreaterThanZero (
 980  *      LARGE_INTEGER   Operand1
 981  *      );
 982  */
 983 #define RtlLargeIntegerGreaterThanZero(X) \
 984         ((((X).HighPart == 0) && ((X).LowPart > 0)) || \
 985           ((X).HighPart > 0 ))
 986
 987 /*
 988  * BOOLEAN
 989  * RtlLargeIntegerLessThan (
 990  *      LARGE_INTEGER   Operand1,
 991  *      LARGE_INTEGER   Operand2
 992  *      );
 993  */
 994 #define RtlLargeIntegerLessThan(X,Y) \
 995         ((((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
 996           ((X).HighPart < (Y).HighPart))
 997
 998 /*
 999  * BOOLEAN
1000  * RtlLargeIntegerLessThanOrEqualTo (
1001  *      LARGE_INTEGER   Operand1,
1002  *      LARGE_INTEGER   Operand2
1003  *      );
1004  */
1005 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) \
1006         ((((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
1007           ((X).HighPart < (Y).HighPart))
1008
1009 /*
1010  * BOOLEAN
1011  * RtlLargeIntegerLessThanOrEqualToZero (
1012  *      LARGE_INTEGER   Operand
1013  *      );
1014  */
1015 #define RtlLargeIntegerLessOrEqualToZero(X) \
1016         (((X).HighPart < 0) || !((X).LowPart | (X).HighPart))
1017
1018 /*
1019  * BOOLEAN
1020  * RtlLargeIntegerLessThanZero (
1021  *      LARGE_INTEGER   Operand
1022  *      );
1023  */
1024 #define RtlLargeIntegerLessThanZero(X) \
1025         (((X).HighPart < 0))
1026
1027 LARGE_INTEGER
1028 STDCALL
1029 RtlLargeIntegerNegate (
1030         LARGE_INTEGER   Subtrahend
1031         );
1032
1033 /*
1034  * BOOLEAN
1035  * RtlLargeIntegerNotEqualTo (
1036  *      LARGE_INTEGER   Operand1,
1037  *      LARGE_INTEGER   Operand2
1038  *      );
1039  */
1040 #define RtlLargeIntegerNotEqualTo(X,Y) \
1041         ((((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1042
1043 /*
1044  * BOOLEAN
1045  * RtlLargeIntegerNotEqualToZero (
1046  *      LARGE_INTEGER   Operand
1047  *      );
1048  */
1049 #define RtlLargeIntegerNotEqualToZero(X) \
1050         (((X).LowPart | (X).HighPart))
1051
1052 LARGE_INTEGER
1053 STDCALL
1054 RtlLargeIntegerShiftLeft (
1055         LARGE_INTEGER   LargeInteger,
1056         CCHAR           ShiftCount
1057         );
1058
1059 LARGE_INTEGER
1060 STDCALL
1061 RtlLargeIntegerShiftRight (
1062         LARGE_INTEGER   LargeInteger,
1063         CCHAR           ShiftCount
1064         );
1065
1066 LARGE_INTEGER
1067 STDCALL
1068 RtlLargeIntegerSubtract (
1069         LARGE_INTEGER   Minuend,
1070         LARGE_INTEGER   Subtrahend
1071         );
1072
1073 ULONG
1074 STDCALL
1075 RtlLengthSecurityDescriptor (
1076         PSECURITY_DESCRIPTOR    SecurityDescriptor
1077         );
1078
1079 BOOL
1080 STDCALL
1081 RtlLockHeap (
1082         HANDLE  hheap
1083         );
1084
1085 NTSTATUS
1086 STDCALL
1087 RtlLookupAtomInAtomTable (
1088         IN      PRTL_ATOM_TABLE AtomTable,
1089         IN      PWSTR           AtomName,
1090         OUT     PRTL_ATOM       Atom
1091         );
1092
1093 #undef RtlMoveMemory
1094
1095 VOID STDCALL
1096 RtlMoveMemory (PVOID Destination, CONST VOID* Source, ULONG Length);
1097
1098 NTSTATUS
1099 STDCALL
1100 RtlMultiByteToUnicodeN (
1101         PWCHAR UnicodeString,
1102         ULONG  UnicodeSize,
1103         PULONG ResultSize,
1104         PCHAR  MbString,
1105         ULONG  MbSize
1106         );
1107
1108 NTSTATUS
1109 STDCALL
1110 RtlMultiByteToUnicodeSize (
1111         PULONG UnicodeSize,
1112         PCHAR  MbString,
1113         ULONG  MbSize
1114         );
1115
1116 DWORD
1117 STDCALL
1118 RtlNtStatusToDosError (
1119         NTSTATUS        StatusCode
1120         );
1121
1122 DWORD
1123 STDCALL
1124 RtlNtStatusToDosErrorNoTeb (
1125         NTSTATUS        StatusCode
1126         );
1127
1128 int
1129 STDCALL
1130 RtlNtStatusToPsxErrno (
1131         NTSTATUS        StatusCode
1132         );
1133
1134 ULONG
1135 STDCALL
1136 RtlNumberGenericTableElements (
1137         IN      PRTL_GENERIC_TABLE      Table
1138         );
1139
1140 ULONG
1141 STDCALL
1142 RtlNumberOfClearBits (
1143         PRTL_BITMAP     BitMapHeader
1144         );
1145
1146 ULONG
1147 STDCALL
1148 RtlNumberOfSetBits (
1149         PRTL_BITMAP     BitMapHeader
1150         );
1151
1152 ULONG
1153 STDCALL
1154 RtlOemStringToUnicodeSize (
1155         POEM_STRING     AnsiString
1156         );
1157
1158 NTSTATUS
1159 STDCALL
1160 RtlOemStringToUnicodeString (
1161         PUNICODE_STRING DestinationString,
1162         POEM_STRING     SourceString,
1163         BOOLEAN         AllocateDestinationString
1164         );
1165
1166 NTSTATUS
1167 STDCALL
1168 RtlOemToUnicodeN (
1169         PWCHAR  UnicodeString,
1170         ULONG   UnicodeSize,
1171         PULONG  ResultSize,
1172         PCHAR   OemString,
1173         ULONG   OemSize
1174         );
1175
1176 NTSTATUS
1177 STDCALL
1178 RtlOpenCurrentUser (
1179         IN      ACCESS_MASK     DesiredAccess,
1180         OUT     PHANDLE         KeyHandle
1181         );
1182
1183 NTSTATUS STDCALL
1184 RtlPinAtomInAtomTable (
1185         IN      PRTL_ATOM_TABLE AtomTable,
1186         IN      RTL_ATOM        Atom
1187         );
1188
1189 BOOLEAN
1190 STDCALL
1191 RtlPrefixString (
1192         PANSI_STRING    String1,
1193         PANSI_STRING    String2,
1194         BOOLEAN         CaseInsensitive
1195         );
1196
1197 BOOLEAN
1198 STDCALL
1199 RtlPrefixUnicodeString (
1200         PUNICODE_STRING String1,
1201         PUNICODE_STRING String2,
1202         BOOLEAN         CaseInsensitive
1203         );
1204
1205 NTSTATUS
1206 STDCALL
1207 RtlQueryAtomInAtomTable (
1208         IN      PRTL_ATOM_TABLE AtomTable,
1209         IN      RTL_ATOM        Atom,
1210         IN OUT  PULONG          RefCount OPTIONAL,
1211         IN OUT  PULONG          PinCount OPTIONAL,
1212         IN OUT  PWSTR           AtomName OPTIONAL,
1213         IN OUT  PULONG          NameLength OPTIONAL
1214         );
1215
1216 NTSTATUS
1217 STDCALL
1218 RtlQueryTimeZoneInformation (
1219         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1220         );
1221
1222 VOID
1223 STDCALL
1224 RtlRaiseException (
1225         IN      PEXCEPTION_RECORD       ExceptionRecord
1226         );
1227
1228 LPVOID
1229 STDCALL
1230 RtlReAllocateHeap (
1231         HANDLE  hheap,
1232         DWORD   flags,
1233         LPVOID  ptr,
1234         DWORD   size
1235         );
1236
1237 /*
1238  * VOID
1239  * RtlRetrieveUlong (
1240  *      PULONG  DestinationAddress,
1241  *      PULONG  SourceAddress
1242  *      );
1243  */
1244 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
1245         if ((ULONG)(SrcAddress) & LONG_MASK) \
1246         { \
1247                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1248                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1249                 ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
1250                 ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
1251         } \
1252         else \
1253         { \
1254                 *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
1255         }
1256
1257 /*
1258  * VOID
1259  * RtlRetrieveUshort (
1260  *      PUSHORT DestinationAddress,
1261  *      PUSHORT SourceAddress
1262  *      );
1263  */
1264 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
1265         if ((ULONG)(SrcAddress) & SHORT_MASK) \
1266         { \
1267                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1268                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1269         } \
1270         else \
1271         { \
1272                 *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
1273         }
1274
1275 VOID
1276 STDCALL
1277 RtlSecondsSince1970ToTime (
1278         ULONG SecondsSince1970,
1279         PLARGE_INTEGER Time
1280         );
1281
1282 VOID
1283 STDCALL
1284 RtlSecondsSince1980ToTime (
1285         ULONG SecondsSince1980,
1286         PLARGE_INTEGER Time
1287         );
1288
1289 VOID
1290 STDCALL
1291 RtlSetAllBits (
1292         IN      PRTL_BITMAP     BitMapHeader
1293         );
1294
1295 VOID
1296 STDCALL
1297 RtlSetBits (
1298         PRTL_BITMAP     BitMapHeader,
1299         ULONG           StartingIndex,
1300         ULONG           NumberToSet
1301         );
1302
1303 NTSTATUS
1304 STDCALL
1305 RtlSetDaclSecurityDescriptor (
1306         PSECURITY_DESCRIPTOR    SecurityDescriptor,
1307         BOOLEAN                 DaclPresent,
1308         PACL                    Dacl,
1309         BOOLEAN                 DaclDefaulted
1310         );
1311
1312 NTSTATUS
1313 STDCALL
1314 RtlSetTimeZoneInformation (
1315         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1316         );
1317
1318 DWORD
1319 STDCALL
1320 RtlSizeHeap (
1321         HANDLE  hheap,
1322         DWORD   flags,
1323         PVOID   pmem
1324         );
1325
1326 /*
1327  * VOID
1328  * RtlStoreUlong (
1329  *      PULONG  Address,
1330  *      ULONG   Value
1331  *      );
1332  */
1333 #define RtlStoreUlong(Address,Value) \
1334         if ((ULONG)(Address) & LONG_MASK) \
1335         { \
1336                 ((PUCHAR)(Address))[LONG_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1337                 ((PUCHAR)(Address))[LONG_3RD_MOST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1338                 ((PUCHAR)(Address))[LONG_2ND_MOST_SIGNIFICANT_BIT]=(UCHAR)(THIRDBYTE(Value)); \
1339                 ((PUCHAR)(Address))[LONG_MOST_SIGNIFICANT_BIT]=(UCHAR)(FOURTHBYTE(Value)); \
1340         } \
1341         else \
1342         { \
1343                 *((PULONG)(Address))=(ULONG)(Value); \
1344         }
1345
1346 /*
1347  * VOID
1348  * RtlStoreUshort (
1349  *      PUSHORT Address,
1350  *      USHORT  Value
1351  *      );
1352  */
1353 #define RtlStoreUshort(Address,Value) \
1354         if ((ULONG)(Address) & SHORT_MASK) \
1355         { \
1356                 ((PUCHAR)(Address))[SHORT_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1357                 ((PUCHAR)(Address))[SHORT_MOST_SIGNIFICANT_BIT]=(UCHAR)(SECONDBYTE(Value)); \
1358         } \
1359         else \
1360         { \
1361                 *((PUSHORT)(Address))=(USHORT)(Value); \
1362         }
1363
1364 BOOLEAN
1365 STDCALL
1366 RtlTimeFieldsToTime (
1367         PTIME_FIELDS    TimeFields,
1368         PLARGE_INTEGER  Time
1369         );
1370
1371 BOOLEAN
1372 STDCALL
1373 RtlTimeToSecondsSince1970 (
1374         PLARGE_INTEGER Time,
1375         PULONG SecondsSince1970
1376         );
1377
1378 BOOLEAN
1379 STDCALL
1380 RtlTimeToSecondsSince1980 (
1381         PLARGE_INTEGER Time,
1382         PULONG SecondsSince1980
1383         );
1384
1385 VOID
1386 STDCALL
1387 RtlTimeToTimeFields (
1388         PLARGE_INTEGER  Time,
1389         PTIME_FIELDS    TimeFields
1390         );
1391
1392 ULONG
1393 STDCALL
1394 RtlUnicodeStringToAnsiSize (
1395         IN      PUNICODE_STRING UnicodeString
1396         );
1397
1398 NTSTATUS
1399 STDCALL
1400 RtlUnicodeStringToAnsiString (
1401         IN OUT  PANSI_STRING    DestinationString,
1402         IN      PUNICODE_STRING SourceString,
1403         IN      BOOLEAN         AllocateDestinationString
1404         );
1405
1406 NTSTATUS
1407 STDCALL
1408 RtlUnicodeStringToInteger (
1409         IN      PUNICODE_STRING String,
1410         IN      ULONG           Base,
1411         OUT     PULONG          Value
1412         );
1413
1414 ULONG
1415 STDCALL
1416 RtlUnicodeStringToOemSize (
1417         IN      PUNICODE_STRING UnicodeString
1418         );
1419
1420 NTSTATUS
1421 STDCALL
1422 RtlUnicodeStringToCountedOemString (
1423         IN OUT  POEM_STRING     DestinationString,
1424         IN      PUNICODE_STRING SourceString,
1425         IN      BOOLEAN         AllocateDestinationString
1426         );
1427
1428 NTSTATUS
1429 STDCALL
1430 RtlUnicodeStringToOemString (
1431         IN OUT  POEM_STRING     DestinationString,
1432         IN      PUNICODE_STRING SourceString,
1433         IN      BOOLEAN         AllocateDestinationString
1434         );
1435
1436 NTSTATUS
1437 STDCALL
1438 RtlUnicodeToCustomCPN (
1439         PRTL_NLS_DATA   NlsData,
1440         PCHAR           MbString,
1441         ULONG           MbSize,
1442         PULONG          ResultSize,
1443         PWCHAR          UnicodeString,
1444         ULONG           UnicodeSize
1445         );
1446
1447 NTSTATUS
1448 STDCALL
1449 RtlUnicodeToMultiByteN (
1450         PCHAR   MbString,
1451         ULONG   MbSize,
1452         PULONG  ResultSize,
1453         PWCHAR  UnicodeString,
1454         ULONG   UnicodeSize
1455         );
1456
1457 NTSTATUS
1458 STDCALL
1459 RtlUnicodeToMultiByteSize (
1460         PULONG  MbSize,
1461         PWCHAR  UnicodeString,
1462         ULONG   UnicodeSize
1463         );
1464
1465 NTSTATUS
1466 STDCALL
1467 RtlUnicodeToOemN (
1468         PCHAR   OemString,
1469         ULONG   OemSize,
1470         PULONG  ResultSize,
1471         PWCHAR  UnicodeString,
1472         ULONG   UnicodeSize
1473         );
1474
1475 BOOL
1476 STDCALL
1477 RtlUnlockHeap (
1478         HANDLE  hheap
1479         );
1480
1481 VOID
1482 STDCALL
1483 RtlUnwind (
1484   PEXCEPTION_REGISTRATION RegistrationFrame,
1485   PVOID ReturnAddress,
1486   PEXCEPTION_RECORD ExceptionRecord,
1487   DWORD EaxValue
1488         );
1489
1490 WCHAR
1491 STDCALL
1492 RtlUpcaseUnicodeChar (
1493         WCHAR Source
1494         );
1495
1496 NTSTATUS
1497 STDCALL
1498 RtlUpcaseUnicodeString (
1499         IN OUT  PUNICODE_STRING DestinationString,
1500         IN      PUNICODE_STRING SourceString,
1501         IN      BOOLEAN         AllocateDestinationString
1502         );
1503
1504 NTSTATUS
1505 STDCALL
1506 RtlUpcaseUnicodeStringToAnsiString (
1507         IN OUT  PANSI_STRING    DestinationString,
1508         IN      PUNICODE_STRING SourceString,
1509         IN      BOOLEAN         AllocateDestinationString
1510         );
1511
1512 NTSTATUS
1513 STDCALL
1514 RtlUpcaseUnicodeStringToCountedOemString (
1515         IN OUT  POEM_STRING     DestinationString,
1516         IN      PUNICODE_STRING SourceString,
1517         IN      BOOLEAN         AllocateDestinationString
1518         );
1519
1520 NTSTATUS
1521 STDCALL
1522 RtlUpcaseUnicodeStringToOemString (
1523         IN OUT  POEM_STRING     DestinationString,
1524         IN      PUNICODE_STRING SourceString,
1525         IN      BOOLEAN         AllocateDestinationString
1526         );
1527
1528 NTSTATUS
1529 STDCALL
1530 RtlUpcaseUnicodeToCustomCPN (
1531         PRTL_NLS_DATA   NlsData,
1532         PCHAR           MbString,
1533         ULONG           MbSize,
1534         PULONG          ResultSize,
1535         PWCHAR          UnicodeString,
1536         ULONG           UnicodeSize
1537         );
1538
1539 NTSTATUS
1540 STDCALL
1541 RtlUpcaseUnicodeToMultiByteN (
1542         PCHAR   MbString,
1543         ULONG   MbSize,
1544         PULONG  ResultSize,
1545         PWCHAR  UnicodeString,
1546         ULONG   UnicodeSize
1547         );
1548
1549 NTSTATUS
1550 STDCALL
1551 RtlUpcaseUnicodeToOemN (
1552         PCHAR   OemString,
1553         ULONG   OemSize,
1554         PULONG  ResultSize,
1555         PWCHAR  UnicodeString,
1556         ULONG   UnicodeSize
1557         );
1558
1559 CHAR
1560 STDCALL
1561 RtlUpperChar (
1562         CHAR    Source
1563         );
1564
1565 VOID
1566 STDCALL
1567 RtlUpperString (
1568         PSTRING DestinationString,
1569         PSTRING SourceString
1570         );
1571
1572 BOOL
1573 STDCALL
1574 RtlValidateHeap (
1575         HANDLE  hheap,
1576         DWORD   flags,
1577         PVOID   pmem
1578         );
1579
1580 BOOLEAN
1581 STDCALL
1582 RtlValidSecurityDescriptor (
1583         PSECURITY_DESCRIPTOR    SecurityDescriptor
1584         );
1585
1586 BOOLEAN STDCALL
1587 RtlValidSid(IN PSID Sid);
1588
1589 #undef RtlZeroMemory
1590
1591 VOID STDCALL
1592 RtlZeroMemory (PVOID Destination, ULONG Length);
1593
1594 ULONG
1595 STDCALL
1596 RtlxAnsiStringToUnicodeSize (
1597         IN      PANSI_STRING    AnsiString
1598         );
1599
1600 ULONG
1601 STDCALL
1602 RtlxOemStringToUnicodeSize (
1603         IN      POEM_STRING     OemString
1604         );
1605
1606 ULONG
1607 STDCALL
1608 RtlxUnicodeStringToAnsiSize (
1609         IN      PUNICODE_STRING UnicodeString
1610         );
1611
1612 ULONG
1613 STDCALL
1614 RtlxUnicodeStringToOemSize (
1615         IN      PUNICODE_STRING UnicodeString
1616         );
1617
1618
1619 /* Register io functions */
1620
1621 UCHAR
1622 STDCALL
1623 READ_REGISTER_UCHAR (
1624         PUCHAR  Register
1625         );
1626
1627 USHORT
1628 STDCALL
1629 READ_REGISTER_USHORT (
1630         PUSHORT Register
1631         );
1632
1633 ULONG
1634 STDCALL
1635 READ_REGISTER_ULONG (
1636         PULONG  Register
1637         );
1638
1639 VOID
1640 STDCALL
1641 READ_REGISTER_BUFFER_UCHAR (
1642         PUCHAR  Register,
1643         PUCHAR  Buffer,
1644         ULONG   Count
1645         );
1646
1647 VOID
1648 STDCALL
1649 READ_REGISTER_BUFFER_USHORT (
1650         PUSHORT Register,
1651         PUSHORT Buffer,
1652         ULONG   Count
1653         );
1654
1655 VOID
1656 STDCALL
1657 READ_REGISTER_BUFFER_ULONG (
1658         PULONG  Register,
1659         PULONG  Buffer,
1660         ULONG   Count
1661         );
1662
1663 VOID
1664 STDCALL
1665 WRITE_REGISTER_UCHAR (
1666         PUCHAR  Register,
1667         UCHAR   Value
1668         );
1669
1670 VOID
1671 STDCALL
1672 WRITE_REGISTER_USHORT (
1673         PUSHORT Register,
1674         USHORT  Value
1675         );
1676
1677 VOID
1678 STDCALL
1679 WRITE_REGISTER_ULONG (
1680         PULONG  Register,
1681         ULONG   Value
1682         );
1683
1684 VOID
1685 STDCALL
1686 WRITE_REGISTER_BUFFER_UCHAR (
1687         PUCHAR  Register,
1688         PUCHAR  Buffer,
1689         ULONG   Count
1690         );
1691
1692 VOID
1693 STDCALL
1694 WRITE_REGISTER_BUFFER_USHORT (
1695         PUSHORT Register,
1696         PUSHORT Buffer,
1697         ULONG   Count
1698         );
1699
1700 VOID
1701 STDCALL
1702 WRITE_REGISTER_BUFFER_ULONG (
1703         PULONG  Register,
1704         PULONG  Buffer,
1705         ULONG   Count
1706         );
1707
1708
1709 NTSTATUS STDCALL RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision);
1710 NTSTATUS STDCALL RtlQueryInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
1711 NTSTATUS STDCALL RtlSetInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
1712 BOOLEAN STDCALL RtlValidAcl (PACL Acl);
1713
1714 NTSTATUS STDCALL RtlAddAccessAllowedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
1715 NTSTATUS STDCALL RtlAddAccessDeniedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
1716 NTSTATUS STDCALL RtlAddAce(PACL Acl, ULONG Revision, ULONG StartingIndex, PACE AceList, ULONG AceListLength);
1717 NTSTATUS STDCALL RtlAddAuditAccessAce (PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid, BOOLEAN Success, BOOLEAN Failure);
1718 NTSTATUS STDCALL RtlDeleteAce(PACL Acl, ULONG AceIndex);
1719 BOOLEAN STDCALL RtlFirstFreeAce(PACL Acl, PACE* Ace);
1720 NTSTATUS STDCALL RtlGetAce(PACL Acl, ULONG AceIndex, PACE *Ace);
1721
1722 NTSTATUS STDCALL RtlAbsoluteToSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
1723 NTSTATUS STDCALL RtlMakeSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
1724 NTSTATUS STDCALL RtlCreateSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG Revision);
1725 BOOLEAN STDCALL RtlValidSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
1726 ULONG STDCALL RtlLengthSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
1727 NTSTATUS STDCALL RtlSetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN DaclPresent, PACL Dacl, BOOLEAN DaclDefaulted);
1728 NTSTATUS STDCALL RtlGetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN DaclPresent, PACL* Dacl, PBOOLEAN DaclDefauted);
1729 NTSTATUS STDCALL RtlSetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Owner, BOOLEAN OwnerDefaulted);
1730 NTSTATUS STDCALL RtlGetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Owner, PBOOLEAN OwnerDefaulted);
1731 NTSTATUS STDCALL RtlSetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Group, BOOLEAN GroupDefaulted);
1732 NTSTATUS STDCALL RtlGetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Group, PBOOLEAN GroupDefaulted);
1733 NTSTATUS STDCALL RtlGetControlSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL Control, PULONG Revision);
1734 NTSTATUS STDCALL RtlSetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN SaclPresent, PACL Sacl, BOOLEAN SaclDefaulted);
1735 NTSTATUS STDCALL RtlGetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN SaclPresent, PACL* Sacl, PBOOLEAN SaclDefauted);
1736 NTSTATUS STDCALL RtlSelfRelativeToAbsoluteSD (PSECURITY_DESCRIPTOR RelSD,
1737                                               PSECURITY_DESCRIPTOR AbsSD,
1738                                               PDWORD AbsSDSize,
1739                                               PACL Dacl,
1740                                               PDWORD DaclSize,
1741                                               PACL Sacl,
1742                                               PDWORD SaclSize,
1743                                               PSID Owner,
1744                                               PDWORD OwnerSize,
1745                                               PSID Group,
1746                                               PDWORD GroupSize);
1747
1748 NTSTATUS STDCALL RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
1749                                               UCHAR SubAuthorityCount,
1750                                               ULONG SubAuthority0,
1751                                               ULONG SubAuthority1,
1752                                               ULONG SubAuthority2,
1753                                               ULONG SubAuthority3,
1754                                               ULONG SubAuthority4,
1755                                               ULONG SubAuthority5,
1756                                               ULONG SubAuthority6,
1757                                               ULONG SubAuthority7,
1758                                               PSID *Sid);
1759 ULONG STDCALL RtlLengthRequiredSid (UCHAR SubAuthorityCount);
1760 PSID_IDENTIFIER_AUTHORITY STDCALL RtlIdentifierAuthoritySid (PSID Sid);
1761 NTSTATUS STDCALL RtlInitializeSid (PSID Sid, PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, UCHAR SubAuthorityCount);
1762 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
1763 NTSTATUS STDCALL RtlCopySid (ULONG BufferLength, PSID Dest, PSID Src);
1764 BOOLEAN STDCALL RtlEqualPrefixSid (PSID Sid1, PSID Sid2);
1765 BOOLEAN STDCALL RtlEqualSid(PSID Sid1, PSID Sid2);
1766 PSID STDCALL RtlFreeSid (PSID Sid);
1767 ULONG STDCALL RtlLengthSid (PSID Sid);
1768 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
1769 PUCHAR STDCALL RtlSubAuthorityCountSid (PSID Sid);
1770 BOOLEAN STDCALL RtlValidSid (PSID Sid);
1771 NTSTATUS STDCALL RtlConvertSidToUnicodeString (PUNICODE_STRING String, PSID Sid, BOOLEAN AllocateBuffer);
1772
1773 BOOLEAN STDCALL RtlAreAllAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
1774 BOOLEAN STDCALL RtlAreAnyAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
1775 VOID STDCALL RtlMapGenericMask (PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping);
1776
1777
1778 /*  functions exported from NTOSKRNL.EXE which are considered RTL  */
1779
1780 #if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined(__NTAPP__)
1781
1782 char *_itoa (int value, char *string, int radix);
1783 int _snprintf(char * buf, size_t cnt, const char *fmt, ...);
1784 int _snwprintf(wchar_t *buf, size_t cnt, const wchar_t *fmt, ...);
1785 int _stricmp(const char *s1, const char *s2);
1786 char * _strlwr(char *x);
1787 int _strnicmp(const char *s1, const char *s2, size_t n);
1788 char * _strnset(char* szToFill, int szFill, size_t sizeMaxFill);
1789 char * _strrev(char *s);
1790 char * _strset(char* szToFill, int szFill);
1791 char * _strupr(char *x);
1792 int _vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args);
1793 int _wcsicmp (const wchar_t* cs, const wchar_t* ct);
1794 wchar_t * _wcslwr (wchar_t *x);
1795 int _wcsnicmp (const wchar_t * cs,const wchar_t * ct,size_t count);
1796 wchar_t* _wcsnset (wchar_t* wsToFill, wchar_t wcFill, size_t sizeMaxFill);
1797 wchar_t * _wcsrev(wchar_t *s);
1798 wchar_t *_wcsupr(wchar_t *x);
1799
1800 int atoi(const char *str);
1801 long atol(const char *str);
1802 int isdigit(int c);
1803 int islower(int c);
1804 int isprint(int c);
1805 int isspace(int c);
1806 int isupper(int c);
1807 int isxdigit(int c);
1808 size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count);
1809 int mbtowc (wchar_t *wchar, const char *mbchar, size_t count);
1810 void * memchr(const void *s, int c, size_t n);
1811 void * memcpy(void *to, const void *from, size_t count);
1812 void * memmove(void *dest,const void *src, size_t count);
1813 void * memset(void *src, int val, size_t count);
1814
1815 #if 0
1816 qsort
1817 #endif
1818
1819 int rand(void);
1820 int sprintf(char * buf, const char *fmt, ...);
1821 void srand(unsigned seed);
1822 char * strcat(char *s, const char *append);
1823 char * strchr(const char *s, int c);
1824 int strcmp(const char *s1, const char *s2);
1825 char * strcpy(char *to, const char *from);
1826 size_t strlen(const char *str);
1827 char * strncat(char *dst, const char *src, size_t n);
1828 int strncmp(const char *s1, const char *s2, size_t n);
1829 char *strncpy(char *dst, const char *src, size_t n);
1830 char *strrchr(const char *s, int c);
1831 size_t strspn(const char *s1, const char *s2);
1832 char *strstr(const char *s, const char *find);
1833 int swprintf(wchar_t *buf, const wchar_t *fmt, ...);
1834 int tolower(int c);
1835 int toupper(int c);
1836 wchar_t towlower(wchar_t c);
1837 wchar_t towupper(wchar_t c);
1838 int vsprintf(char *buf, const char *fmt, va_list args);
1839 wchar_t * wcscat(wchar_t *dest, const wchar_t *src);
1840 wchar_t * wcschr(const wchar_t *str, wchar_t ch);
1841 int wcscmp(const wchar_t *cs, const wchar_t *ct);
1842 wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2);
1843 size_t wcscspn(const wchar_t *str,const wchar_t *reject);
1844 size_t wcslen(const wchar_t *s);
1845 wchar_t * wcsncat(wchar_t *dest, const wchar_t *src, size_t count);
1846 int wcsncmp(const wchar_t *cs, const wchar_t *ct, size_t count);
1847 wchar_t * wcsncpy(wchar_t *dest, const wchar_t *src, size_t count);
1848 wchar_t * wcsrchr(const wchar_t *str, wchar_t ch);
1849 size_t wcsspn(const wchar_t *str,const wchar_t *accept);
1850 wchar_t *wcsstr(const wchar_t *s,const wchar_t *b);
1851 size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count);
1852 int wctomb (char *mbchar, wchar_t wchar);
1853
1854 #endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
1855
1856 #endif /* __DDK_RTL_H */