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