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