reactos/include/ntos/rtl.h

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