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 /* Prevent hide of the inappropriate passed type by our
1101  * de"const" of the string in the macro below.
1102  */
1103 static inline const WCHAR *_RtlInitUnicodeStringFromLiteral_typecheck(const WCHAR *s) { return s; }
1104
1105 #define RtlInitUnicodeStringFromLiteral(__PDEST_STRING__,__SOURCE_STRING__) \
1106  InitializeUnicodeString( \
1107   (__PDEST_STRING__), \
1108   sizeof(__SOURCE_STRING__) - sizeof(WCHAR), \
1109   sizeof(__SOURCE_STRING__), \
1110   (WCHAR * /* de"const" the string here */ )_RtlInitUnicodeStringFromLiteral_typecheck((__SOURCE_STRING__)) \
1111  )
1112
1113 /*
1114  Static initializer for UNICODE_STRING variables. Usage:
1115
1116  UNICODE_STRING wstr = UNICODE_STRING_INITIALIZER(L"string");
1117
1118 */
1119
1120 #define UNICODE_STRING_INITIALIZER(__SOURCE_STRING__) \
1121 { \
1122  sizeof((__SOURCE_STRING__)) - sizeof(WCHAR), \
1123  sizeof((__SOURCE_STRING__)), \
1124  (__SOURCE_STRING__) \
1125 }
1126
1127 /*
1128  Initializer for empty UNICODE_STRING variables. Usage:
1129
1130  UNICODE_STRING wstr = EMPTY_UNICODE_STRING;
1131
1132 */
1133 #define EMPTY_UNICODE_STRING {0, 0, NULL}
1134
1135 VOID
1136 STDCALL
1137 RtlInitializeBitMap (
1138         IN OUT  PRTL_BITMAP     BitMapHeader,
1139         IN      PULONG          BitMapBuffer,
1140         IN      ULONG           SizeOfBitMap
1141         );
1142
1143 NTSTATUS
1144 STDCALL
1145 RtlInitializeContext (
1146         IN      HANDLE                  ProcessHandle,
1147         IN      PCONTEXT                Context,
1148         IN      PVOID                   Parameter,
1149         IN      PTHREAD_START_ROUTINE   StartAddress,
1150         IN OUT  PINITIAL_TEB            InitialTeb
1151         );
1152
1153 VOID
1154 STDCALL
1155 RtlInitializeGenericTable (
1156         IN OUT  PRTL_GENERIC_TABLE      Table,
1157         IN      PVOID                   CompareRoutine,
1158         IN      PVOID                   AllocateRoutine,
1159         IN      PVOID                   FreeRoutine,
1160         IN      ULONG                   UserParameter
1161         );
1162
1163 PVOID
1164 STDCALL
1165 RtlInsertElementGenericTable (
1166         IN OUT  PRTL_GENERIC_TABLE      Table,
1167         IN      PVOID                   Element,
1168         IN      ULONG                   ElementSize,
1169         IN      ULONG                   Unknown4
1170         );
1171
1172 NTSTATUS
1173 STDCALL
1174 RtlIntegerToChar (
1175         IN      ULONG   Value,
1176         IN      ULONG   Base,
1177         IN      ULONG   Length,
1178         IN OUT  PCHAR   String
1179         );
1180
1181 NTSTATUS
1182 STDCALL
1183 RtlIntegerToUnicodeString (
1184         IN      ULONG           Value,
1185         IN      ULONG           Base,
1186         IN OUT  PUNICODE_STRING String
1187         );
1188
1189 BOOLEAN
1190 STDCALL
1191 RtlIsGenericTableEmpty (
1192         IN      PRTL_GENERIC_TABLE      Table
1193         );
1194
1195 BOOLEAN STDCALL
1196 RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName,
1197                        IN PANSI_STRING AnsiName,
1198                        OUT PBOOLEAN SpacesFound);
1199
1200 LARGE_INTEGER
1201 STDCALL
1202 RtlLargeIntegerAdd (
1203         LARGE_INTEGER   Addend1,
1204         LARGE_INTEGER   Addend2
1205         );
1206
1207 /*
1208  * VOID
1209  * RtlLargeIntegerAnd (
1210  *      PLARGE_INTEGER  Result,
1211  *      LARGE_INTEGER   Source,
1212  *      LARGE_INTEGER   Mask
1213  *      );
1214  */
1215 #define RtlLargeIntegerAnd(Result, Source, Mask) \
1216 { \
1217         Result.HighPart = Source.HighPart & Mask.HighPart; \
1218         Result.LowPart = Source.LowPart & Mask.LowPart; \
1219 }
1220
1221 LARGE_INTEGER
1222 STDCALL
1223 RtlLargeIntegerArithmeticShift (
1224         LARGE_INTEGER   LargeInteger,
1225         CCHAR   ShiftCount
1226         );
1227
1228 LARGE_INTEGER
1229 STDCALL
1230 RtlLargeIntegerDivide (
1231         LARGE_INTEGER   Dividend,
1232         LARGE_INTEGER   Divisor,
1233         PLARGE_INTEGER  Remainder
1234         );
1235
1236 /*
1237  * BOOLEAN
1238  * RtlLargeIntegerEqualTo (
1239  *      LARGE_INTEGER   Operand1,
1240  *      LARGE_INTEGER   Operand2
1241  *      );
1242  */
1243 #define RtlLargeIntegerEqualTo(X,Y) \
1244         (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1245
1246 /*
1247  * BOOLEAN
1248  * RtlLargeIntegerEqualToZero (
1249  *      LARGE_INTEGER   Operand
1250  *      );
1251  */
1252 #define RtlLargeIntegerEqualToZero(X) \
1253         (!((X).LowPart | (X).HighPart))
1254
1255 /*
1256  * BOOLEAN
1257  * RtlLargeIntegerGreaterThan (
1258  *      LARGE_INTEGER   Operand1,
1259  *      LARGE_INTEGER   Operand2
1260  *      );
1261  */
1262 #define RtlLargeIntegerGreaterThan(X,Y) \
1263         ((((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
1264           ((X).HighPart > (Y).HighPart))
1265
1266 /*
1267  * BOOLEAN
1268  * RtlLargeIntegerGreaterThanOrEqualTo (
1269  *      LARGE_INTEGER   Operand1,
1270  *      LARGE_INTEGER   Operand2
1271  *      );
1272  */
1273 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) \
1274         ((((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
1275           ((X).HighPart > (Y).HighPart))
1276
1277 /*
1278  * BOOLEAN
1279  * RtlLargeIntegerGreaterThanOrEqualToZero (
1280  *      LARGE_INTEGER   Operand1
1281  *      );
1282  */
1283 #define RtlLargeIntegerGreaterOrEqualToZero(X) \
1284         ((X).HighPart >= 0)
1285
1286 /*
1287  * BOOLEAN
1288  * RtlLargeIntegerGreaterThanZero (
1289  *      LARGE_INTEGER   Operand1
1290  *      );
1291  */
1292 #define RtlLargeIntegerGreaterThanZero(X) \
1293         ((((X).HighPart == 0) && ((X).LowPart > 0)) || \
1294           ((X).HighPart > 0 ))
1295
1296 /*
1297  * BOOLEAN
1298  * RtlLargeIntegerLessThan (
1299  *      LARGE_INTEGER   Operand1,
1300  *      LARGE_INTEGER   Operand2
1301  *      );
1302  */
1303 #define RtlLargeIntegerLessThan(X,Y) \
1304         ((((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
1305           ((X).HighPart < (Y).HighPart))
1306
1307 /*
1308  * BOOLEAN
1309  * RtlLargeIntegerLessThanOrEqualTo (
1310  *      LARGE_INTEGER   Operand1,
1311  *      LARGE_INTEGER   Operand2
1312  *      );
1313  */
1314 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) \
1315         ((((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
1316           ((X).HighPart < (Y).HighPart))
1317
1318 /*
1319  * BOOLEAN
1320  * RtlLargeIntegerLessThanOrEqualToZero (
1321  *      LARGE_INTEGER   Operand
1322  *      );
1323  */
1324 #define RtlLargeIntegerLessOrEqualToZero(X) \
1325         (((X).HighPart < 0) || !((X).LowPart | (X).HighPart))
1326
1327 /*
1328  * BOOLEAN
1329  * RtlLargeIntegerLessThanZero (
1330  *      LARGE_INTEGER   Operand
1331  *      );
1332  */
1333 #define RtlLargeIntegerLessThanZero(X) \
1334         (((X).HighPart < 0))
1335
1336 LARGE_INTEGER
1337 STDCALL
1338 RtlLargeIntegerNegate (
1339         LARGE_INTEGER   Subtrahend
1340         );
1341
1342 /*
1343  * BOOLEAN
1344  * RtlLargeIntegerNotEqualTo (
1345  *      LARGE_INTEGER   Operand1,
1346  *      LARGE_INTEGER   Operand2
1347  *      );
1348  */
1349 #define RtlLargeIntegerNotEqualTo(X,Y) \
1350         ((((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1351
1352 /*
1353  * BOOLEAN
1354  * RtlLargeIntegerNotEqualToZero (
1355  *      LARGE_INTEGER   Operand
1356  *      );
1357  */
1358 #define RtlLargeIntegerNotEqualToZero(X) \
1359         (((X).LowPart | (X).HighPart))
1360
1361 LARGE_INTEGER
1362 STDCALL
1363 RtlLargeIntegerShiftLeft (
1364         LARGE_INTEGER   LargeInteger,
1365         CCHAR           ShiftCount
1366         );
1367
1368 LARGE_INTEGER
1369 STDCALL
1370 RtlLargeIntegerShiftRight (
1371         LARGE_INTEGER   LargeInteger,
1372         CCHAR           ShiftCount
1373         );
1374
1375 LARGE_INTEGER
1376 STDCALL
1377 RtlLargeIntegerSubtract (
1378         LARGE_INTEGER   Minuend,
1379         LARGE_INTEGER   Subtrahend
1380         );
1381
1382 ULONG
1383 STDCALL
1384 RtlLengthSecurityDescriptor (
1385         PSECURITY_DESCRIPTOR    SecurityDescriptor
1386         );
1387
1388 BOOL
1389 STDCALL
1390 RtlLockHeap (
1391         HANDLE  hheap
1392         );
1393
1394 NTSTATUS
1395 STDCALL
1396 RtlLookupAtomInAtomTable (
1397         IN      PRTL_ATOM_TABLE AtomTable,
1398         IN      PWSTR           AtomName,
1399         OUT     PRTL_ATOM       Atom
1400         );
1401
1402 VOID STDCALL
1403 RtlMoveMemory (PVOID Destination, CONST VOID* Source, ULONG Length);
1404
1405 NTSTATUS
1406 STDCALL
1407 RtlMultiByteToUnicodeN (
1408         PWCHAR UnicodeString,
1409         ULONG  UnicodeSize,
1410         PULONG ResultSize,
1411         PCHAR  MbString,
1412         ULONG  MbSize
1413         );
1414
1415 NTSTATUS
1416 STDCALL
1417 RtlMultiByteToUnicodeSize (
1418         PULONG UnicodeSize,
1419         PCHAR  MbString,
1420         ULONG  MbSize
1421         );
1422
1423 DWORD
1424 STDCALL
1425 RtlNtStatusToDosError (
1426         NTSTATUS        StatusCode
1427         );
1428
1429 DWORD
1430 STDCALL
1431 RtlNtStatusToDosErrorNoTeb (
1432         NTSTATUS        StatusCode
1433         );
1434
1435 int
1436 STDCALL
1437 RtlNtStatusToPsxErrno (
1438         NTSTATUS        StatusCode
1439         );
1440
1441 ULONG
1442 STDCALL
1443 RtlNumberGenericTableElements (
1444         IN      PRTL_GENERIC_TABLE      Table
1445         );
1446
1447 ULONG
1448 STDCALL
1449 RtlNumberOfClearBits (
1450         PRTL_BITMAP     BitMapHeader
1451         );
1452
1453 ULONG
1454 STDCALL
1455 RtlNumberOfSetBits (
1456         PRTL_BITMAP     BitMapHeader
1457         );
1458
1459 ULONG
1460 STDCALL
1461 RtlOemStringToUnicodeSize (
1462         POEM_STRING     AnsiString
1463         );
1464
1465 NTSTATUS
1466 STDCALL
1467 RtlOemStringToUnicodeString (
1468         PUNICODE_STRING DestinationString,
1469         POEM_STRING     SourceString,
1470         BOOLEAN         AllocateDestinationString
1471         );
1472
1473 NTSTATUS
1474 STDCALL
1475 RtlOemToUnicodeN (
1476         PWCHAR  UnicodeString,
1477         ULONG   UnicodeSize,
1478         PULONG  ResultSize,
1479         PCHAR   OemString,
1480         ULONG   OemSize
1481         );
1482
1483 NTSTATUS
1484 STDCALL
1485 RtlOpenCurrentUser (
1486         IN      ACCESS_MASK     DesiredAccess,
1487         OUT     PHANDLE         KeyHandle
1488         );
1489
1490 NTSTATUS STDCALL
1491 RtlPinAtomInAtomTable (
1492         IN      PRTL_ATOM_TABLE AtomTable,
1493         IN      RTL_ATOM        Atom
1494         );
1495
1496 BOOLEAN
1497 STDCALL
1498 RtlPrefixString (
1499         PANSI_STRING    String1,
1500         PANSI_STRING    String2,
1501         BOOLEAN         CaseInsensitive
1502         );
1503
1504 BOOLEAN
1505 STDCALL
1506 RtlPrefixUnicodeString (
1507         PUNICODE_STRING String1,
1508         PUNICODE_STRING String2,
1509         BOOLEAN         CaseInsensitive
1510         );
1511
1512 NTSTATUS
1513 STDCALL
1514 RtlQueryAtomInAtomTable (
1515         IN      PRTL_ATOM_TABLE AtomTable,
1516         IN      RTL_ATOM        Atom,
1517         IN OUT  PULONG          RefCount OPTIONAL,
1518         IN OUT  PULONG          PinCount OPTIONAL,
1519         IN OUT  PWSTR           AtomName OPTIONAL,
1520         IN OUT  PULONG          NameLength OPTIONAL
1521         );
1522
1523 NTSTATUS
1524 STDCALL
1525 RtlQueryRegistryValues (
1526         IN      ULONG                           RelativeTo,
1527         IN      PWSTR                           Path,
1528         IN      PRTL_QUERY_REGISTRY_TABLE       QueryTable,
1529         IN      PVOID                           Context,
1530         IN      PVOID                           Environment
1531         );
1532
1533 NTSTATUS
1534 STDCALL
1535 RtlQueryTimeZoneInformation (
1536         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1537         );
1538
1539 VOID
1540 STDCALL
1541 RtlRaiseException (
1542         IN      PEXCEPTION_RECORD       ExceptionRecord
1543         );
1544
1545 LPVOID
1546 STDCALL
1547 RtlReAllocateHeap (
1548         HANDLE  hheap,
1549         DWORD   flags,
1550         LPVOID  ptr,
1551         DWORD   size
1552         );
1553
1554 NTSTATUS STDCALL
1555 RtlReserveChunk(IN USHORT CompressionFormat,
1556                 IN OUT PUCHAR *CompressedBuffer,
1557                 IN PUCHAR EndOfCompressedBufferPlus1,
1558                 OUT PUCHAR *ChunkBuffer,
1559                 IN ULONG ChunkSize);
1560
1561 /*
1562  * VOID
1563  * RtlRetrieveUlong (
1564  *      PULONG  DestinationAddress,
1565  *      PULONG  SourceAddress
1566  *      );
1567  */
1568 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
1569         if ((ULONG)(SrcAddress) & LONG_MASK) \
1570         { \
1571                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1572                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1573                 ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
1574                 ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
1575         } \
1576         else \
1577         { \
1578                 *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
1579         }
1580
1581 /*
1582  * VOID
1583  * RtlRetrieveUshort (
1584  *      PUSHORT DestinationAddress,
1585  *      PUSHORT SourceAddress
1586  *      );
1587  */
1588 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
1589         if ((ULONG)(SrcAddress) & SHORT_MASK) \
1590         { \
1591                 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
1592                 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
1593         } \
1594         else \
1595         { \
1596                 *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
1597         }
1598
1599 VOID
1600 STDCALL
1601 RtlSecondsSince1970ToTime (
1602         ULONG SecondsSince1970,
1603         PLARGE_INTEGER Time
1604         );
1605
1606 VOID
1607 STDCALL
1608 RtlSecondsSince1980ToTime (
1609         ULONG SecondsSince1980,
1610         PLARGE_INTEGER Time
1611         );
1612
1613 VOID
1614 STDCALL
1615 RtlSetAllBits (
1616         IN      PRTL_BITMAP     BitMapHeader
1617         );
1618
1619 VOID
1620 STDCALL
1621 RtlSetBits (
1622         PRTL_BITMAP     BitMapHeader,
1623         ULONG           StartingIndex,
1624         ULONG           NumberToSet
1625         );
1626
1627 NTSTATUS
1628 STDCALL
1629 RtlSetDaclSecurityDescriptor (
1630         PSECURITY_DESCRIPTOR    SecurityDescriptor,
1631         BOOLEAN                 DaclPresent,
1632         PACL                    Dacl,
1633         BOOLEAN                 DaclDefaulted
1634         );
1635
1636 NTSTATUS
1637 STDCALL
1638 RtlSetTimeZoneInformation (
1639         IN OUT  PTIME_ZONE_INFORMATION  TimeZoneInformation
1640         );
1641
1642 DWORD
1643 STDCALL
1644 RtlSizeHeap (
1645         HANDLE  hheap,
1646         DWORD   flags,
1647         PVOID   pmem
1648         );
1649
1650 /*
1651  * VOID
1652  * RtlStoreUlong (
1653  *      PULONG  Address,
1654  *      ULONG   Value
1655  *      );
1656  */
1657 #define RtlStoreUlong(Address,Value) \
1658         if ((ULONG)(Address) & LONG_MASK) \
1659         { \
1660                 ((PUCHAR)(Address))[LONG_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1661                 ((PUCHAR)(Address))[LONG_3RD_MOST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1662                 ((PUCHAR)(Address))[LONG_2ND_MOST_SIGNIFICANT_BIT]=(UCHAR)(THIRDBYTE(Value)); \
1663                 ((PUCHAR)(Address))[LONG_MOST_SIGNIFICANT_BIT]=(UCHAR)(FOURTHBYTE(Value)); \
1664         } \
1665         else \
1666         { \
1667                 *((PULONG)(Address))=(ULONG)(Value); \
1668         }
1669
1670 /*
1671  * VOID
1672  * RtlStoreUshort (
1673  *      PUSHORT Address,
1674  *      USHORT  Value
1675  *      );
1676  */
1677 #define RtlStoreUshort(Address,Value) \
1678         if ((ULONG)(Address) & SHORT_MASK) \
1679         { \
1680                 ((PUCHAR)(Address))[SHORT_LEAST_SIGNIFICANT_BIT]=(UCHAR)(FIRSTBYTE(Value)); \
1681                 ((PUCHAR)(Address))[SHORT_MOST_SIGNIFICANT_BIT]=(UCHAR)(SECONDBYTE(Value)); \
1682         } \
1683         else \
1684         { \
1685                 *((PUSHORT)(Address))=(USHORT)(Value); \
1686         }
1687
1688 BOOLEAN
1689 STDCALL
1690 RtlTimeFieldsToTime (
1691         PTIME_FIELDS    TimeFields,
1692         PLARGE_INTEGER  Time
1693         );
1694
1695 BOOLEAN
1696 STDCALL
1697 RtlTimeToSecondsSince1970 (
1698         PLARGE_INTEGER Time,
1699         PULONG SecondsSince1970
1700         );
1701
1702 BOOLEAN
1703 STDCALL
1704 RtlTimeToSecondsSince1980 (
1705         PLARGE_INTEGER Time,
1706         PULONG SecondsSince1980
1707         );
1708
1709 VOID
1710 STDCALL
1711 RtlTimeToTimeFields (
1712         PLARGE_INTEGER  Time,
1713         PTIME_FIELDS    TimeFields
1714         );
1715
1716 ULONG
1717 STDCALL
1718 RtlUnicodeStringToAnsiSize (
1719         IN      PUNICODE_STRING UnicodeString
1720         );
1721
1722 NTSTATUS
1723 STDCALL
1724 RtlUnicodeStringToAnsiString (
1725         IN OUT  PANSI_STRING    DestinationString,
1726         IN      PUNICODE_STRING SourceString,
1727         IN      BOOLEAN         AllocateDestinationString
1728         );
1729
1730 NTSTATUS
1731 STDCALL
1732 RtlUnicodeStringToInteger (
1733         IN      PUNICODE_STRING String,
1734         IN      ULONG           Base,
1735         OUT     PULONG          Value
1736         );
1737
1738 ULONG
1739 STDCALL
1740 RtlUnicodeStringToOemSize (
1741         IN      PUNICODE_STRING UnicodeString
1742         );
1743
1744 NTSTATUS
1745 STDCALL
1746 RtlUnicodeStringToCountedOemString (
1747         IN OUT  POEM_STRING     DestinationString,
1748         IN      PUNICODE_STRING SourceString,
1749         IN      BOOLEAN         AllocateDestinationString
1750         );
1751
1752 NTSTATUS
1753 STDCALL
1754 RtlUnicodeStringToOemString (
1755         IN OUT  POEM_STRING     DestinationString,
1756         IN      PUNICODE_STRING SourceString,
1757         IN      BOOLEAN         AllocateDestinationString
1758         );
1759
1760 NTSTATUS
1761 STDCALL
1762 RtlUnicodeToCustomCPN (
1763         PRTL_NLS_DATA   NlsData,
1764         PCHAR           MbString,
1765         ULONG           MbSize,
1766         PULONG          ResultSize,
1767         PWCHAR          UnicodeString,
1768         ULONG           UnicodeSize
1769         );
1770
1771 NTSTATUS
1772 STDCALL
1773 RtlUnicodeToMultiByteN (
1774         PCHAR   MbString,
1775         ULONG   MbSize,
1776         PULONG  ResultSize,
1777         PWCHAR  UnicodeString,
1778         ULONG   UnicodeSize
1779         );
1780
1781 NTSTATUS
1782 STDCALL
1783 RtlUnicodeToMultiByteSize (
1784         PULONG  MbSize,
1785         PWCHAR  UnicodeString,
1786         ULONG   UnicodeSize
1787         );
1788
1789 NTSTATUS
1790 STDCALL
1791 RtlUnicodeToOemN (
1792         PCHAR   OemString,
1793         ULONG   OemSize,
1794         PULONG  ResultSize,
1795         PWCHAR  UnicodeString,
1796         ULONG   UnicodeSize
1797         );
1798
1799 BOOL
1800 STDCALL
1801 RtlUnlockHeap (
1802         HANDLE  hheap
1803         );
1804
1805 VOID
1806 STDCALL
1807 RtlUnwind (
1808   PEXCEPTION_REGISTRATION RegistrationFrame,
1809   PVOID ReturnAddress,
1810   PEXCEPTION_RECORD ExceptionRecord,
1811   DWORD EaxValue
1812         );
1813
1814 WCHAR
1815 STDCALL
1816 RtlUpcaseUnicodeChar (
1817         WCHAR Source
1818         );
1819
1820 NTSTATUS
1821 STDCALL
1822 RtlUpcaseUnicodeString (
1823         IN OUT  PUNICODE_STRING DestinationString,
1824         IN      PUNICODE_STRING SourceString,
1825         IN      BOOLEAN         AllocateDestinationString
1826         );
1827
1828 NTSTATUS
1829 STDCALL
1830 RtlUpcaseUnicodeStringToAnsiString (
1831         IN OUT  PANSI_STRING    DestinationString,
1832         IN      PUNICODE_STRING SourceString,
1833         IN      BOOLEAN         AllocateDestinationString
1834         );
1835
1836 NTSTATUS
1837 STDCALL
1838 RtlUpcaseUnicodeStringToCountedOemString (
1839         IN OUT  POEM_STRING     DestinationString,
1840         IN      PUNICODE_STRING SourceString,
1841         IN      BOOLEAN         AllocateDestinationString
1842         );
1843
1844 NTSTATUS
1845 STDCALL
1846 RtlUpcaseUnicodeStringToOemString (
1847         IN OUT  POEM_STRING     DestinationString,
1848         IN      PUNICODE_STRING SourceString,
1849         IN      BOOLEAN         AllocateDestinationString
1850         );
1851
1852 NTSTATUS
1853 STDCALL
1854 RtlUpcaseUnicodeToCustomCPN (
1855         PRTL_NLS_DATA   NlsData,
1856         PCHAR           MbString,
1857         ULONG           MbSize,
1858         PULONG          ResultSize,
1859         PWCHAR          UnicodeString,
1860         ULONG           UnicodeSize
1861         );
1862
1863 NTSTATUS
1864 STDCALL
1865 RtlUpcaseUnicodeToMultiByteN (
1866         PCHAR   MbString,
1867         ULONG   MbSize,
1868         PULONG  ResultSize,
1869         PWCHAR  UnicodeString,
1870         ULONG   UnicodeSize
1871         );
1872
1873 NTSTATUS
1874 STDCALL
1875 RtlUpcaseUnicodeToOemN (
1876         PCHAR   OemString,
1877         ULONG   OemSize,
1878         PULONG  ResultSize,
1879         PWCHAR  UnicodeString,
1880         ULONG   UnicodeSize
1881         );
1882
1883 CHAR
1884 STDCALL
1885 RtlUpperChar (
1886         CHAR    Source
1887         );
1888
1889 VOID
1890 STDCALL
1891 RtlUpperString (
1892         PSTRING DestinationString,
1893         PSTRING SourceString
1894         );
1895
1896 BOOL
1897 STDCALL
1898 RtlValidateHeap (
1899         HANDLE  hheap,
1900         DWORD   flags,
1901         PVOID   pmem
1902         );
1903
1904 BOOLEAN
1905 STDCALL
1906 RtlValidSecurityDescriptor (
1907         PSECURITY_DESCRIPTOR    SecurityDescriptor
1908         );
1909
1910 BOOLEAN STDCALL
1911 RtlValidSid(IN PSID Sid);
1912
1913 NTSTATUS
1914 STDCALL
1915 RtlWriteRegistryValue (
1916         ULONG   RelativeTo,
1917         PWSTR   Path,
1918         PWSTR   ValueName,
1919         ULONG   ValueType,
1920         PVOID   ValueData,
1921         ULONG   ValueLength
1922         );
1923
1924 VOID STDCALL
1925 RtlZeroMemory (PVOID Destination, ULONG Length);
1926
1927 ULONG
1928 STDCALL
1929 RtlxAnsiStringToUnicodeSize (
1930         IN      PANSI_STRING    AnsiString
1931         );
1932
1933 ULONG
1934 STDCALL
1935 RtlxOemStringToUnicodeSize (
1936         IN      POEM_STRING     OemString
1937         );
1938
1939 ULONG
1940 STDCALL
1941 RtlxUnicodeStringToAnsiSize (
1942         IN      PUNICODE_STRING UnicodeString
1943         );
1944
1945 ULONG
1946 STDCALL
1947 RtlxUnicodeStringToOemSize (
1948         IN      PUNICODE_STRING UnicodeString
1949         );
1950
1951
1952 /* Register io functions */
1953
1954 UCHAR
1955 STDCALL
1956 READ_REGISTER_UCHAR (
1957         PUCHAR  Register
1958         );
1959
1960 USHORT
1961 STDCALL
1962 READ_REGISTER_USHORT (
1963         PUSHORT Register
1964         );
1965
1966 ULONG
1967 STDCALL
1968 READ_REGISTER_ULONG (
1969         PULONG  Register
1970         );
1971
1972 VOID
1973 STDCALL
1974 READ_REGISTER_BUFFER_UCHAR (
1975         PUCHAR  Register,
1976         PUCHAR  Buffer,
1977         ULONG   Count
1978         );
1979
1980 VOID
1981 STDCALL
1982 READ_REGISTER_BUFFER_USHORT (
1983         PUSHORT Register,
1984         PUSHORT Buffer,
1985         ULONG   Count
1986         );
1987
1988 VOID
1989 STDCALL
1990 READ_REGISTER_BUFFER_ULONG (
1991         PULONG  Register,
1992         PULONG  Buffer,
1993         ULONG   Count
1994         );
1995
1996 VOID
1997 STDCALL
1998 WRITE_REGISTER_UCHAR (
1999         PUCHAR  Register,
2000         UCHAR   Value
2001         );
2002
2003 VOID
2004 STDCALL
2005 WRITE_REGISTER_USHORT (
2006         PUSHORT Register,
2007         USHORT  Value
2008         );
2009
2010 VOID
2011 STDCALL
2012 WRITE_REGISTER_ULONG (
2013         PULONG  Register,
2014         ULONG   Value
2015         );
2016
2017 VOID
2018 STDCALL
2019 WRITE_REGISTER_BUFFER_UCHAR (
2020         PUCHAR  Register,
2021         PUCHAR  Buffer,
2022         ULONG   Count
2023         );
2024
2025 VOID
2026 STDCALL
2027 WRITE_REGISTER_BUFFER_USHORT (
2028         PUSHORT Register,
2029         PUSHORT Buffer,
2030         ULONG   Count
2031         );
2032
2033 VOID
2034 STDCALL
2035 WRITE_REGISTER_BUFFER_ULONG (
2036         PULONG  Register,
2037         PULONG  Buffer,
2038         ULONG   Count
2039         );
2040
2041
2042 NTSTATUS STDCALL RtlCreateAcl(PACL Acl, ULONG AclSize, ULONG AclRevision);
2043 NTSTATUS STDCALL RtlQueryInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
2044 NTSTATUS STDCALL RtlSetInformationAcl (PACL Acl, PVOID Information, ULONG InformationLength, ACL_INFORMATION_CLASS InformationClass);
2045 BOOLEAN STDCALL RtlValidAcl (PACL Acl);
2046
2047 NTSTATUS STDCALL RtlAddAccessAllowedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
2048 NTSTATUS STDCALL RtlAddAccessDeniedAce(PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid);
2049 NTSTATUS STDCALL RtlAddAce(PACL Acl, ULONG Revision, ULONG StartingIndex, PACE AceList, ULONG AceListLength);
2050 NTSTATUS STDCALL RtlAddAuditAccessAce (PACL Acl, ULONG Revision, ACCESS_MASK AccessMask, PSID Sid, BOOLEAN Success, BOOLEAN Failure);
2051 NTSTATUS STDCALL RtlDeleteAce(PACL Acl, ULONG AceIndex);
2052 BOOLEAN STDCALL RtlFirstFreeAce(PACL Acl, PACE* Ace);
2053 NTSTATUS STDCALL RtlGetAce(PACL Acl, ULONG AceIndex, PACE *Ace);
2054
2055 NTSTATUS STDCALL RtlAbsoluteToSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
2056 NTSTATUS STDCALL RtlMakeSelfRelativeSD (PSECURITY_DESCRIPTOR AbsSD, PSECURITY_DESCRIPTOR RelSD, PULONG BufferLength);
2057 NTSTATUS STDCALL RtlCreateSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG Revision);
2058 BOOLEAN STDCALL RtlValidSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
2059 ULONG STDCALL RtlLengthSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor);
2060 NTSTATUS STDCALL RtlSetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN DaclPresent, PACL Dacl, BOOLEAN DaclDefaulted);
2061 NTSTATUS STDCALL RtlGetDaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN DaclPresent, PACL* Dacl, PBOOLEAN DaclDefauted);
2062 NTSTATUS STDCALL RtlSetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Owner, BOOLEAN OwnerDefaulted);
2063 NTSTATUS STDCALL RtlGetOwnerSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Owner, PBOOLEAN OwnerDefaulted);
2064 NTSTATUS STDCALL RtlSetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID Group, BOOLEAN GroupDefaulted);
2065 NTSTATUS STDCALL RtlGetGroupSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSID* Group, PBOOLEAN GroupDefaulted);
2066 NTSTATUS STDCALL RtlGetControlSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL Control, PULONG Revision);
2067 NTSTATUS STDCALL RtlSetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, BOOLEAN SaclPresent, PACL Sacl, BOOLEAN SaclDefaulted);
2068 NTSTATUS STDCALL RtlGetSaclSecurityDescriptor (PSECURITY_DESCRIPTOR SecurityDescriptor, PBOOLEAN SaclPresent, PACL* Sacl, PBOOLEAN SaclDefauted);
2069 NTSTATUS STDCALL RtlSelfRelativeToAbsoluteSD (PSECURITY_DESCRIPTOR RelSD,
2070                                               PSECURITY_DESCRIPTOR AbsSD,
2071                                               PDWORD AbsSDSize,
2072                                               PACL Dacl,
2073                                               PDWORD DaclSize,
2074                                               PACL Sacl,
2075                                               PDWORD SaclSize,
2076                                               PSID Owner,
2077                                               PDWORD OwnerSize,
2078                                               PSID Group,
2079                                               PDWORD GroupSize);
2080
2081 NTSTATUS STDCALL RtlAllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
2082                                               UCHAR SubAuthorityCount,
2083                                               ULONG SubAuthority0,
2084                                               ULONG SubAuthority1,
2085                                               ULONG SubAuthority2,
2086                                               ULONG SubAuthority3,
2087                                               ULONG SubAuthority4,
2088                                               ULONG SubAuthority5,
2089                                               ULONG SubAuthority6,
2090                                               ULONG SubAuthority7,
2091                                               PSID *Sid);
2092 ULONG STDCALL RtlLengthRequiredSid (UCHAR SubAuthorityCount);
2093 PSID_IDENTIFIER_AUTHORITY STDCALL RtlIdentifierAuthoritySid (PSID Sid);
2094 NTSTATUS STDCALL RtlInitializeSid (PSID Sid, PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, UCHAR SubAuthorityCount);
2095 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
2096 BOOLEAN STDCALL RtlEqualPrefixSid (PSID Sid1, PSID Sid2);
2097 BOOLEAN STDCALL RtlEqualSid(PSID Sid1, PSID Sid2);
2098 PSID STDCALL RtlFreeSid (PSID Sid);
2099 ULONG STDCALL RtlLengthSid (PSID Sid);
2100 PULONG STDCALL RtlSubAuthoritySid (PSID Sid, ULONG SubAuthority);
2101 PUCHAR STDCALL RtlSubAuthorityCountSid (PSID Sid);
2102 BOOLEAN STDCALL RtlValidSid (PSID Sid);
2103 NTSTATUS STDCALL RtlConvertSidToUnicodeString (PUNICODE_STRING String, PSID Sid, BOOLEAN AllocateBuffer);
2104
2105 BOOLEAN STDCALL RtlAreAllAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
2106 BOOLEAN STDCALL RtlAreAnyAccessesGranted (ACCESS_MASK GrantedAccess, ACCESS_MASK DesiredAccess);
2107 VOID STDCALL RtlMapGenericMask (PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping);
2108
2109
2110 /*  functions exported from NTOSKRNL.EXE which are considered RTL  */
2111
2112 #if defined(__NTOSKRNL__) || defined(__NTDRIVER__) || defined(__NTHAL__) || defined(__NTDLL__) || defined(__NTAPP__)
2113
2114 char *_itoa (int value, char *string, int radix);
2115 int _snprintf(char * buf, size_t cnt, const char *fmt, ...);
2116 int _snwprintf(wchar_t *buf, size_t cnt, const wchar_t *fmt, ...);
2117 int _stricmp(const char *s1, const char *s2);
2118 char * _strlwr(char *x);
2119 int _strnicmp(const char *s1, const char *s2, size_t n);
2120 char * _strnset(char* szToFill, int szFill, size_t sizeMaxFill);
2121 char * _strrev(char *s);
2122 char * _strset(char* szToFill, int szFill);
2123 char * _strupr(char *x);
2124 int _vsnprintf(char *buf, size_t cnt, const char *fmt, va_list args);
2125 int _wcsicmp (const wchar_t* cs, const wchar_t* ct);
2126 wchar_t * _wcslwr (wchar_t *x);
2127 int _wcsnicmp (const wchar_t * cs,const wchar_t * ct,size_t count);
2128 wchar_t* _wcsnset (wchar_t* wsToFill, wchar_t wcFill, size_t sizeMaxFill);
2129 wchar_t * _wcsrev(wchar_t *s);
2130 wchar_t *_wcsupr(wchar_t *x);
2131
2132 int atoi(const char *str);
2133 long atol(const char *str);
2134 int isdigit(int c);
2135 int islower(int c);
2136 int isprint(int c);
2137 int isspace(int c);
2138 int isupper(int c);
2139 int isxdigit(int c);
2140 size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count);
2141 int mbtowc (wchar_t *wchar, const char *mbchar, size_t count);
2142 void * memchr(const void *s, int c, size_t n);
2143 void * memcpy(void *to, const void *from, size_t count);
2144 void * memmove(void *dest,const void *src, size_t count);
2145 void * memset(void *src, int val, size_t count);
2146
2147 #if 0
2148 qsort
2149 #endif
2150
2151 int rand(void);
2152 int sprintf(char * buf, const char *fmt, ...);
2153 void srand(unsigned seed);
2154 char * strcat(char *s, const char *append);
2155 char * strchr(const char *s, int c);
2156 int strcmp(const char *s1, const char *s2);
2157 char * strcpy(char *to, const char *from);
2158 size_t strlen(const char *str);
2159 char * strncat(char *dst, const char *src, size_t n);
2160 int strncmp(const char *s1, const char *s2, size_t n);
2161 char *strncpy(char *dst, const char *src, size_t n);
2162 char *strrchr(const char *s, int c);
2163 size_t strspn(const char *s1, const char *s2);
2164 char *strstr(const char *s, const char *find);
2165 int swprintf(wchar_t *buf, const wchar_t *fmt, ...);
2166 int tolower(int c);
2167 int toupper(int c);
2168 wchar_t towlower(wchar_t c);
2169 wchar_t towupper(wchar_t c);
2170 int vsprintf(char *buf, const char *fmt, va_list args);
2171 wchar_t * wcscat(wchar_t *dest, const wchar_t *src);
2172 wchar_t * wcschr(const wchar_t *str, wchar_t ch);
2173 int wcscmp(const wchar_t *cs, const wchar_t *ct);
2174 wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2);
2175 size_t wcscspn(const wchar_t *str,const wchar_t *reject);
2176 size_t wcslen(const wchar_t *s);
2177 wchar_t * wcsncat(wchar_t *dest, const wchar_t *src, size_t count);
2178 int wcsncmp(const wchar_t *cs, const wchar_t *ct, size_t count);
2179 wchar_t * wcsncpy(wchar_t *dest, const wchar_t *src, size_t count);
2180 wchar_t * wcsrchr(const wchar_t *str, wchar_t ch);
2181 size_t wcsspn(const wchar_t *str,const wchar_t *accept);
2182 wchar_t *wcsstr(const wchar_t *s,const wchar_t *b);
2183 size_t wcstombs (char *mbstr, const wchar_t *wcstr, size_t count);
2184 int wctomb (char *mbchar, wchar_t wchar);
2185
2186 #endif /* __NTOSKRNL__ || __NTDRIVER__ || __NTHAL__ || __NTDLL__ || __NTAPP__ */
2187
2188 #endif /* __DDK_RTL_H */