reactos/include/ntos/rtl.h

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