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