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