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