reactos/include/ntos/rtl.h

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