include/ntos/rtl.h

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