reactos/include/ntos/rtl.h

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