reactos/include/ntos/rtl.h

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