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