include/winternl.h

   1 /*
   2  * Internal NT APIs and data structures
   3  *
   4  * Copyright (C) the Wine project
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef __WINE_WINTERNAL_H
  22 #define __WINE_WINTERNAL_H
  23
  24 #include "windef.h"
  25 #include "winnt.h"
  26 #include "winreg.h"
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif /* defined(__cplusplus) */
  31
  32 /***********************************************************************
  33  * PEB data structure
  34  */
  35 typedef struct _PEB {
  36   BYTE Reserved1[2];
  37   BYTE BeingDebugged;
  38   BYTE Reserved2[229];
  39   PVOID Reserved3[59];
  40   ULONG SessionId;
  41 } PEB, *PPEB;
  42
  43 /***********************************************************************
  44  * TEB data structure
  45  */
  46 #if 0
  47 typedef struct _TEB {
  48   BYTE Reserved1[1952];
  49   PVOID Reserved2[412];
  50   PVOID TlsSlots[64];
  51   BYTE Reserved3[8];
  52   PVOID Reserved4[26];
  53   PVOID ReservedForOle; /* Windows 2000 only */
  54   PVOID Reserved5[4];
  55   PVOID TlsExpansionSlots;
  56 } TEB, *PTEB;
  57 #endif
  58
  59 /**********************************************************************
  60  * Fundamental types and data structures
  61  */
  62
  63 typedef LONG NTSTATUS;
  64
  65 typedef CONST char *PCSZ;
  66
  67 typedef short CSHORT;
  68 typedef CSHORT *PCSHORT;
  69
  70 typedef struct _STRING {
  71   USHORT Length;
  72   USHORT MaximumLength;
  73   PCHAR Buffer;
  74 } STRING, *PSTRING;
  75
  76 typedef STRING ANSI_STRING;
  77 typedef PSTRING PANSI_STRING;
  78 typedef const STRING *PCANSI_STRING;
  79
  80 typedef STRING OEM_STRING;
  81 typedef PSTRING POEM_STRING;
  82 typedef const STRING *PCOEM_STRING;
  83
  84 typedef struct _UNICODE_STRING {
  85   USHORT Length;        /* bytes */
  86   USHORT MaximumLength; /* bytes */
  87   PWSTR  Buffer;
  88 } UNICODE_STRING, *PUNICODE_STRING;
  89
  90 typedef const UNICODE_STRING *PCUNICODE_STRING;
  91
  92 typedef struct _CLIENT_ID
  93 {
  94    HANDLE UniqueProcess;
  95    HANDLE UniqueThread;
  96 } CLIENT_ID, *PCLIENT_ID;
  97
  98 typedef struct _CURDIR
  99 {
 100     UNICODE_STRING DosPath;
 101     PVOID Handle;
 102 } CURDIR, *PCURDIR;
 103
 104 /***********************************************************************
 105  * Enums
 106  */
 107
 108 typedef enum _FILE_INFORMATION_CLASS {
 109     FileDirectoryInformation = 1,
 110     FileFullDirectoryInformation,
 111     FileBothDirectoryInformation,
 112     FileBasicInformation,
 113     FileStandardInformation,
 114     FileInternalInformation,
 115     FileEaInformation,
 116     FileAccessInformation,
 117     FileNameInformation,
 118     FileRenameInformation,
 119     FileLinkInformation,
 120     FileNamesInformation,
 121     FileDispositionInformation,
 122     FilePositionInformation,
 123     FileFullEaInformation,
 124     FileModeInformation,
 125     FileAlignmentInformation,
 126     FileAllInformation,
 127     FileAllocationInformation,
 128     FileEndOfFileInformation,
 129     FileAlternateNameInformation,
 130     FileStreamInformation,
 131     FilePipeInformation,
 132     FilePipeLocalInformation,
 133     FilePipeRemoteInformation,
 134     FileMailslotQueryInformation,
 135     FileMailslotSetInformation,
 136     FileCompressionInformation,
 137     FileObjectIdInformation,
 138     FileCompletionInformation,
 139     FileMoveClusterInformation,
 140     FileQuotaInformation,
 141     FileReparsePointInformation,
 142     FileNetworkOpenInformation,
 143     FileAttributeTagInformation,
 144     FileTrackingInformation,
 145     FileMaximumInformation
 146 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
 147
 148 typedef struct _FILE_BASIC_INFORMATION {
 149     LARGE_INTEGER CreationTime;
 150     LARGE_INTEGER LastAccessTime;
 151     LARGE_INTEGER LastWriteTime;
 152     LARGE_INTEGER ChangeTime;
 153     ULONG FileAttributes;
 154 } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
 155
 156 typedef struct _FILE_STANDARD_INFORMATION {
 157     LARGE_INTEGER AllocationSize;
 158     LARGE_INTEGER EndOfFile;
 159     ULONG NumberOfLinks;
 160     BOOLEAN DeletePending;
 161     BOOLEAN Directory;
 162 } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
 163
 164 typedef struct _FILE_POSITION_INFORMATION {
 165     LARGE_INTEGER CurrentByteOffset;
 166 } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
 167
 168 typedef struct _FILE_ALIGNMENT_INFORMATION {
 169     ULONG AlignmentRequirement;
 170 } FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
 171
 172 typedef struct _FILE_NETWORK_OPEN_INFORMATION {
 173     LARGE_INTEGER CreationTime;
 174     LARGE_INTEGER LastAccessTime;
 175     LARGE_INTEGER LastWriteTime;
 176     LARGE_INTEGER ChangeTime;
 177     LARGE_INTEGER AllocationSize;
 178     LARGE_INTEGER EndOfFile;
 179     ULONG FileAttributes;
 180 } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
 181
 182 typedef struct _FILE_FULL_EA_INFORMATION {
 183     ULONG NextEntryOffset;
 184     UCHAR Flags;
 185     UCHAR EaNameLength;
 186     USHORT EaValueLength;
 187     CHAR EaName[1];
 188 } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
 189
 190 typedef struct _FILE_STREAM_INFORMATION
 191 {
 192     ULONG NextEntryOffset;
 193     ULONG StreamNameLength;
 194     LARGE_INTEGER StreamSize;
 195     LARGE_INTEGER StreamAllocationSize;
 196     WCHAR StreamName[1];
 197 } FILE_STREAM_INFORMATION, *PFILE_STREAM_INFORMATION;
 198
 199 struct _FILE_ATTRIBUTE_TAG_INFORMATION
 200 {
 201     ULONG FileAttributes;
 202     ULONG ReparseTag;
 203 } FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION;
 204
 205 typedef enum _FSINFOCLASS {
 206     FileFsVolumeInformation = 1,
 207     FileFsLabelInformation,
 208     FileFsSizeInformation,
 209     FileFsDeviceInformation,
 210     FileFsAttributeInformation,
 211     FileFsControlInformation,
 212     FileFsFullSizeInformation,
 213     FileFsObjectIdInformation,
 214     FileFsMaximumInformation
 215 } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
 216
 217 typedef enum _KEY_INFORMATION_CLASS {
 218     KeyBasicInformation,
 219     KeyNodeInformation,
 220     KeyFullInformation
 221 } KEY_INFORMATION_CLASS;
 222
 223 typedef enum _KEY_VALUE_INFORMATION_CLASS {
 224     KeyValueBasicInformation,
 225     KeyValueFullInformation,
 226     KeyValuePartialInformation,
 227     KeyValueFullInformationAlign64,
 228     KeyValuePartialInformationAlign64
 229 } KEY_VALUE_INFORMATION_CLASS;
 230
 231 typedef enum _OBJECT_INFORMATION_CLASS {
 232     DunnoTheConstants1 /* FIXME */
 233 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
 234
 235 typedef enum _PROCESSINFOCLASS {
 236     ProcessBasicInformation = 0,
 237     ProcessQuotaLimits = 1,
 238     ProcessIoCounters = 2,
 239     ProcessVmCounters = 3,
 240     ProcessTimes = 4,
 241     ProcessBasePriority = 5,
 242     ProcessRaisePriority = 6,
 243     ProcessDebugPort = 7,
 244     ProcessExceptionPort = 8,
 245     ProcessAccessToken = 9,
 246     ProcessLdtInformation = 10,
 247     ProcessLdtSize = 11,
 248     ProcessDefaultHardErrorMode = 12,
 249     ProcessIoPortHandlers = 13,
 250     ProcessPooledUsageAndLimits = 14,
 251     ProcessWorkingSetWatch = 15,
 252     ProcessUserModeIOPL = 16,
 253     ProcessEnableAlignmentFaultFixup = 17,
 254     ProcessPriorityClass = 18,
 255     ProcessWx86Information = 19,
 256     ProcessHandleCount = 20,
 257     ProcessAffinityMask = 21,
 258     ProcessPriorityBoost = 22,
 259     ProcessDeviceMap = 23,
 260     ProcessSessionInformation = 24,
 261     ProcessForegroundInformation = 25,
 262     ProcessWow64Information = 26,
 263     MaxProcessInfoClass
 264 } PROCESSINFOCLASS;
 265
 266 typedef enum _SECTION_INHERIT {
 267     ViewShare = 1,
 268     ViewUnmap = 2
 269 } SECTION_INHERIT;
 270
 271 typedef enum SYSTEM_INFORMATION_CLASS {
 272     SystemBasicInformation = 0,
 273     Unknown1,
 274     SystemPerformanceInformation = 2,
 275     SystemTimeOfDayInformation = 3, /* was SystemTimeInformation */
 276     Unknown4,
 277     SystemProcessInformation = 5,
 278     Unknown6,
 279     Unknown7,
 280     SystemProcessorPerformanceInformation = 8,
 281     Unknown9,
 282     Unknown10,
 283     SystemDriverInformation,
 284     Unknown12,
 285     Unknown13,
 286     Unknown14,
 287     Unknown15,
 288     SystemHandleList,
 289     Unknown17,
 290     Unknown18,
 291     Unknown19,
 292     Unknown20,
 293     SystemCacheInformation,
 294     Unknown22,
 295     SystemInterruptInformation = 23,
 296     SystemExceptionInformation = 33,
 297     SystemRegistryQuotaInformation = 37,
 298     SystemLookasideInformation = 45
 299 } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
 300
 301 typedef enum _TIMER_TYPE {
 302     NotificationTimer,
 303     SynchronizationTimer
 304 } TIMER_TYPE;
 305
 306 typedef enum _THREADINFOCLASS {
 307     ThreadBasicInformation,
 308     ThreadTimes,
 309     ThreadPriority,
 310     ThreadBasePriority,
 311     ThreadAffinityMask,
 312     ThreadImpersonationToken,
 313     ThreadDescriptorTableEntry,
 314     ThreadEnableAlignmentFaultFixup,
 315     ThreadEventPair_Reusable,
 316     ThreadQuerySetWin32StartAddress,
 317     ThreadZeroTlsCell,
 318     ThreadPerformanceCount,
 319     ThreadAmILastThread,
 320     ThreadIdealProcessor,
 321     ThreadPriorityBoost,
 322     ThreadSetTlsArrayAddress,
 323     ThreadIsIoPending,
 324     MaxThreadInfoClass
 325 } THREADINFOCLASS;
 326
 327 typedef enum _WINSTATIONINFOCLASS {
 328     WinStationInformation = 8
 329 } WINSTATIONINFOCLASS;
 330
 331 typedef enum
 332 {
 333     MemoryBasicInformation = 0
 334 } MEMORY_INFORMATION_CLASS;
 335
 336 /* return type of RtlDetermineDosPathNameType_U (FIXME: not the correct names) */
 337 typedef enum
 338 {
 339     INVALID_PATH = 0,
 340     UNC_PATH,              /* "//foo" */
 341     ABSOLUTE_DRIVE_PATH,   /* "c:/foo" */
 342     RELATIVE_DRIVE_PATH,   /* "c:foo" */
 343     ABSOLUTE_PATH,         /* "/foo" */
 344     RELATIVE_PATH,         /* "foo" */
 345     DEVICE_PATH,           /* "//./foo" */
 346     UNC_DOT_PATH           /* "//." */
 347 } DOS_PATHNAME_TYPE;
 348
 349 /***********************************************************************
 350  * IA64 specific types and data structures
 351  */
 352
 353 #ifdef __ia64__
 354
 355 typedef struct _FRAME_POINTERS {
 356   ULONGLONG MemoryStackFp;
 357   ULONGLONG BackingStoreFp;
 358 } FRAME_POINTERS, *PFRAME_POINTERS;
 359
 360 #define UNWIND_HISTORY_TABLE_SIZE 12
 361
 362 typedef struct _RUNTIME_FUNCTION {
 363   ULONG BeginAddress;
 364   ULONG EndAddress;
 365   ULONG UnwindInfoAddress;
 366 } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION;
 367
 368 typedef struct _UNWIND_HISTORY_TABLE_ENTRY {
 369   ULONG64 ImageBase;
 370   ULONG64 Gp;
 371   PRUNTIME_FUNCTION FunctionEntry;
 372 } UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY;
 373
 374 typedef struct _UNWIND_HISTORY_TABLE {
 375   ULONG Count;
 376   UCHAR Search;
 377   ULONG64 LowAddress;
 378   ULONG64 HighAddress;
 379   UNWIND_HISTORY_TABLE_ENTRY Entry[UNWIND_HISTORY_TABLE_SIZE];
 380 } UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE;
 381
 382 #endif /* defined(__ia64__) */
 383
 384 /***********************************************************************
 385  * Types and data structures
 386  */
 387
 388 /* This is used by NtQuerySystemInformation */
 389 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 390 typedef struct {
 391     FILETIME ftCreationTime;
 392     DWORD dwUnknown1;
 393     DWORD dwStartAddress;
 394     DWORD dwOwningPID;
 395     DWORD dwThreadID;
 396     DWORD dwCurrentPriority;
 397     DWORD dwBasePriority;
 398     DWORD dwContextSwitches;
 399     DWORD dwThreadState;
 400     DWORD dwWaitReason;
 401     DWORD dwUnknown2[5];
 402 } THREADINFO, *PTHREADINFO;
 403
 404 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 405 typedef struct _THREAD_INFO{
 406     DWORD Unknown1[6];
 407     DWORD ThreadID;
 408     DWORD Unknown2[3];
 409     DWORD Status;
 410     DWORD WaitReason;
 411     DWORD Unknown3[4];
 412 } THREAD_INFO, PTHREAD_INFO;
 413
 414 /***********************************************************************
 415  * Types and data structures
 416  */
 417
 418 typedef struct _IO_STATUS_BLOCK {
 419   union {
 420     NTSTATUS Status;
 421     PVOID Pointer;
 422   } DUMMYUNIONNAME;
 423
 424   ULONG_PTR Information;
 425 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
 426
 427 typedef void (WINAPI * PIO_APC_ROUTINE)(PVOID,PIO_STATUS_BLOCK,ULONG);
 428
 429 typedef struct _KEY_BASIC_INFORMATION {
 430     LARGE_INTEGER LastWriteTime;
 431     ULONG         TitleIndex;
 432     ULONG         NameLength;
 433     WCHAR         Name[1];
 434 } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
 435
 436 typedef struct _KEY_NODE_INFORMATION
 437 {
 438     LARGE_INTEGER LastWriteTime;
 439     ULONG         TitleIndex;
 440     ULONG         ClassOffset;
 441     ULONG         ClassLength;
 442     ULONG         NameLength;
 443     WCHAR         Name[1];
 444    /* Class[1]; */
 445 } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
 446
 447 typedef struct _KEY_FULL_INFORMATION
 448 {
 449     LARGE_INTEGER LastWriteTime;
 450     ULONG         TitleIndex;
 451     ULONG         ClassOffset;
 452     ULONG         ClassLength;
 453     ULONG         SubKeys;
 454     ULONG         MaxNameLen;
 455     ULONG         MaxClassLen;
 456     ULONG         Values;
 457     ULONG         MaxValueNameLen;
 458     ULONG         MaxValueDataLen;
 459     WCHAR         Class[1];
 460 } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
 461
 462 typedef struct _KEY_VALUE_ENTRY
 463 {
 464     PUNICODE_STRING ValueName;
 465     ULONG           DataLength;
 466     ULONG           DataOffset;
 467     ULONG           Type;
 468 } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
 469
 470 typedef struct _KEY_VALUE_BASIC_INFORMATION {
 471     ULONG TitleIndex;
 472     ULONG Type;
 473     ULONG NameLength;
 474     WCHAR Name[1];
 475 } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
 476
 477 typedef struct _KEY_VALUE_FULL_INFORMATION {
 478     ULONG TitleIndex;
 479     ULONG Type;
 480     ULONG DataOffset;
 481     ULONG DataLength;
 482     ULONG NameLength;
 483     WCHAR Name[1];
 484 } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
 485
 486 typedef struct _KEY_VALUE_PARTIAL_INFORMATION {
 487     ULONG TitleIndex;
 488     ULONG Type;
 489     ULONG DataLength;
 490     UCHAR Data[1];
 491 } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
 492
 493 typedef struct _OBJECT_ATTRIBUTES {
 494   ULONG Length;
 495   HANDLE RootDirectory;
 496   PUNICODE_STRING ObjectName;
 497   ULONG Attributes;
 498   PVOID SecurityDescriptor;       /* type SECURITY_DESCRIPTOR */
 499   PVOID SecurityQualityOfService; /* type SECURITY_QUALITY_OF_SERVICE */
 500 } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
 501
 502 typedef struct _PROCESS_BASIC_INFORMATION {
 503 #ifdef __WINESRC__
 504     DWORD ExitStatus;
 505     DWORD PebBaseAddress;
 506     DWORD AffinityMask;
 507     DWORD BasePriority;
 508     ULONG UniqueProcessId;
 509     ULONG InheritedFromUniqueProcessId;
 510 #else
 511     PVOID Reserved1;
 512     PPEB PebBaseAddress;
 513     PVOID Reserved2[2];
 514     ULONG_PTR UniqueProcessId;
 515     PVOID Reserved3;
 516 #endif
 517 } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
 518
 519 typedef struct _PROCESS_INFO {
 520     DWORD    Offset;             /* 00 offset to next PROCESS_INFO ok*/
 521     DWORD    ThreadCount;        /* 04 number of ThreadInfo member ok */
 522     DWORD    Unknown1[6];
 523     FILETIME CreationTime;       /* 20 */
 524     DWORD    Unknown2[5];
 525     PWCHAR   ProcessName;        /* 3c ok */
 526     DWORD    BasePriority;
 527     DWORD    ProcessID;          /* 44 ok*/
 528     DWORD    ParentProcessID;
 529     DWORD    HandleCount;
 530     DWORD    Unknown3[2];        /* 50 */
 531     ULONG    PeakVirtualSize;
 532     ULONG    VirtualSize;
 533     ULONG    PageFaultCount;
 534     ULONG    PeakWorkingSetSize;
 535     ULONG    WorkingSetSize;
 536     ULONG    QuotaPeakPagedPoolUsage;
 537     ULONG    QuotaPagedPoolUsage;
 538     ULONG    QuotaPeakNonPagedPoolUsage;
 539     ULONG    QuotaNonPagedPoolUsage;
 540     ULONG    PagefileUsage;
 541     ULONG    PeakPagefileUsage;
 542     DWORD    PrivateBytes;
 543     DWORD    Unknown6[4];
 544     THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/
 545 } PROCESS_INFO, PPROCESS_INFO;
 546
 547 typedef struct _RTL_HEAP_DEFINITION {
 548     ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
 549
 550     ULONG Unknown[11];
 551 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 552
 553 typedef struct tagRTL_BITMAP {
 554     ULONG  SizeOfBitMap; /* Number of bits in the bitmap */
 555     LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */
 556 } RTL_BITMAP, *PRTL_BITMAP;
 557
 558 typedef const RTL_BITMAP *PCRTL_BITMAP;
 559
 560 typedef struct tagRTL_BITMAP_RUN {
 561     ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */
 562     ULONG SizeOfRun;  /* Size of the run in bits - FIXME: Name? */
 563 } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
 564
 565 typedef const RTL_BITMAP_RUN *PCRTL_BITMAP_RUN;
 566
 567 typedef struct _RTL_RWLOCK {
 568     RTL_CRITICAL_SECTION rtlCS;
 569
 570     HANDLE hSharedReleaseSemaphore;
 571     UINT   uSharedWaiters;
 572
 573     HANDLE hExclusiveReleaseSemaphore;
 574     UINT   uExclusiveWaiters;
 575
 576     INT    iNumberActive;
 577     HANDLE hOwningThreadId;
 578     DWORD  dwTimeoutBoost;
 579     PVOID  pDebugInfo;
 580 } RTL_RWLOCK, *LPRTL_RWLOCK;
 581
 582 /* System Information Class 0x00 */
 583 typedef struct _SYSTEM_BASIC_INFORMATION {
 584 #ifdef __WINESRC__
 585     DWORD dwUnknown1;
 586     ULONG uKeMaximumIncrement;
 587     ULONG uPageSize;
 588     ULONG uMmNumberOfPhysicalPages;
 589     ULONG uMmLowestPhysicalPage;
 590     ULONG uMmHighestPhysicalPage;
 591     ULONG uAllocationGranularity;
 592     PVOID pLowestUserAddress;
 593     PVOID pMmHighestUserAddress;
 594     ULONG uKeActiveProcessors;
 595     BYTE bKeNumberProcessors;
 596     BYTE bUnknown2;
 597     WORD wUnknown3;
 598 #else
 599     BYTE Reserved1[24];
 600     PVOID Reserved2[4];
 601     CCHAR NumberOfProcessors;
 602 #endif
 603 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 604
 605 /* System Information Class 0x15 */
 606 typedef struct {
 607     ULONG CurrentSize;
 608     ULONG PeakSize;
 609     ULONG PageFaultCount;
 610     ULONG MinimumWorkingSet;
 611     ULONG MaximumWorkingSet;
 612     ULONG unused[4];
 613 } SYSTEM_CACHE_INFORMATION;
 614
 615 typedef struct _SYSTEM_CONFIGURATION_INFO {
 616     union {
 617         ULONG   OemId;
 618         struct {
 619             WORD ProcessorArchitecture;
 620             WORD Reserved;
 621         } tag1;
 622     } tag2;
 623     ULONG PageSize;
 624     PVOID MinimumApplicationAddress;
 625     PVOID MaximumApplicationAddress;
 626     ULONG ActiveProcessorMask;
 627     ULONG NumberOfProcessors;
 628     ULONG ProcessorType;
 629     ULONG AllocationGranularity;
 630     WORD  ProcessorLevel;
 631     WORD  ProcessorRevision;
 632 } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
 633
 634 /* System Information Class 0x0b */
 635 typedef struct {
 636     PVOID pvAddress;
 637     DWORD dwUnknown1;
 638     DWORD dwUnknown2;
 639     DWORD dwEntryIndex;
 640     DWORD dwUnknown3;
 641     char szName[MAX_PATH + 1];
 642 } SYSTEM_DRIVER_INFORMATION;
 643
 644 typedef struct _SYSTEM_EXCEPTION_INFORMATION {
 645     BYTE Reserved1[16];
 646 } SYSTEM_EXCEPTION_INFORMATION, *PSYSTEM_EXCEPTION_INFORMATION;
 647
 648 typedef struct _SYSTEM_LOOKASIDE_INFORMATION {
 649     BYTE Reserved1[32];
 650 } SYSTEM_LOOKASIDE_INFORMATION, *PSYSTEM_LOOKASIDE_INFORMATION;
 651
 652 typedef struct _SYSTEM_INTERRUPT_INFORMATION {
 653     BYTE Reserved1[24];
 654 } SYSTEM_INTERRUPT_INFORMATION, *PSYSTEM_INTERRUPT_INFORMATION;
 655
 656 /* System Information Class 0x10 */
 657 typedef struct {
 658     USHORT dwPID;
 659     USHORT dwCreatorBackTraceIndex;
 660     BYTE bObjectType;
 661     BYTE bHandleAttributes;
 662     USHORT usHandleOffset;
 663     DWORD dwKeObject;
 664     ULONG ulGrantedAccess;
 665 } HANDLEINFO, *PHANDLEINFO; /* FIXME: SYSTEM_HANDLE_INFORMATION? */
 666
 667 typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
 668     BYTE Reserved1[312];
 669 } SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
 670
 671 /* System Information Class 0x02 */
 672 typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
 673 #ifdef __WINESRC__
 674     LARGE_INTEGER liIdleTime;
 675     DWORD dwSpare[76];
 676 #else
 677     LARGE_INTEGER IdleTime;
 678     LARGE_INTEGER KernelTime;
 679     LARGE_INTEGER UserTime;
 680     LARGE_INTEGER Reserved1[2];
 681     ULONG Reserved2;
 682 #endif
 683 } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
 684
 685 /* System Information Class 0x05 */
 686 typedef struct _SYSTEM_PROCESS_INFORMATION {
 687 #ifdef __WINESRC__
 688     DWORD dwOffset;
 689     DWORD dwThreadCount;
 690     DWORD dwUnknown1[6];
 691     FILETIME ftCreationTime;
 692     DWORD dwUnknown2[5];
 693     WCHAR *pszProcessName;
 694     DWORD dwBasePriority;
 695     DWORD dwProcessID;
 696     DWORD dwParentProcessID;
 697     DWORD dwHandleCount;
 698     DWORD dwUnknown3;
 699     DWORD dwUnknown4;
 700     DWORD dwVirtualBytesPeak;
 701     DWORD dwVirtualBytes;
 702     DWORD dwPageFaults;
 703     DWORD dwWorkingSetPeak;
 704     DWORD dwWorkingSet;
 705     DWORD dwUnknown5;
 706     DWORD dwPagedPool;
 707     DWORD dwUnknown6;
 708     DWORD dwNonPagedPool;
 709     DWORD dwPageFileBytesPeak;
 710     DWORD dwPrivateBytes;
 711     DWORD dwPageFileBytes;
 712     DWORD dwUnknown7[4];
 713     THREADINFO ti[1];
 714 #else
 715     ULONG NextEntryOffset;
 716     BYTE Reserved1[52];
 717     PVOID Reserved2[3];
 718     HANDLE UniqueProcessId;
 719     PVOID Reserved3;
 720     ULONG HandleCount;
 721     BYTE Reserved4[4];
 722     PVOID Reserved5[11];
 723     SIZE_T PeakPagefileUsage;
 724     SIZE_T PrivatePageCount;
 725     LARGE_INTEGER Reserved6[6];
 726 #endif
 727 } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
 728
 729 typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {
 730     ULONG RegistryQuotaAllowed;
 731     ULONG RegistryQuotaUsed;
 732     PVOID Reserved1;
 733 } SYSTEM_REGISTRY_QUOTA_INFORMATION, *PSYSTEM_REGISTRY_QUOTA_INFORMATION;
 734
 735 typedef struct _SYSTEM_TIME_ADJUSTMENT {
 736     ULONG   TimeAdjustment;
 737     BOOLEAN TimeAdjustmentDisabled;
 738 } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
 739
 740 /* System Information Class 0x03 */
 741 typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {
 742 #ifdef __WINESRC__
 743     LARGE_INTEGER liKeBootTime;
 744     LARGE_INTEGER liKeSystemTime;
 745     LARGE_INTEGER liExpTimeZoneBias;
 746     ULONG uCurrentTimeZoneId;
 747     DWORD dwReserved;
 748 #else
 749     BYTE Reserved1[48];
 750 #endif
 751 } SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; /* was SYSTEM_TIME_INFORMATION */
 752
 753 typedef struct _TIME_FIELDS
 754 {   CSHORT Year;
 755     CSHORT Month;
 756     CSHORT Day;
 757     CSHORT Hour;
 758     CSHORT Minute;
 759     CSHORT Second;
 760     CSHORT Milliseconds;
 761     CSHORT Weekday;
 762 } TIME_FIELDS, *PTIME_FIELDS;
 763
 764 typedef struct _WINSTATIONINFORMATIONW {
 765   BYTE Reserved2[70];
 766   ULONG LogonId;
 767   BYTE Reserved3[1140];
 768 } WINSTATIONINFORMATIONW, *PWINSTATIONINFORMATIONW;
 769
 770 typedef struct _VM_COUNTERS_ {
 771     ULONG PeakVirtualSize;
 772     ULONG VirtualSize;
 773     ULONG PageFaultCount;
 774     ULONG PeakWorkingSetSize;
 775     ULONG WorkingSetSize;
 776     ULONG QuotaPeakPagedPoolUsage;
 777     ULONG QuotaPagedPoolUsage;
 778     ULONG QuotaPeakNonPagedPoolUsage;
 779     ULONG QuotaNonPagedPoolUsage;
 780     ULONG PagefileUsage;
 781     ULONG PeakPagefileUsage;
 782 } VM_COUNTERS, *PVM_COUNTERS;
 783
 784 typedef BOOLEAN (WINAPI * PWINSTATIONQUERYINFORMATIONW)(HANDLE,ULONG,WINSTATIONINFOCLASS,PVOID,ULONG,PULONG);
 785
 786 typedef struct _LDR_RESOURCE_INFO
 787 {
 788     ULONG Type;
 789     ULONG Name;
 790     ULONG Language;
 791 } LDR_RESOURCE_INFO, *PLDR_RESOURCE_INFO;
 792
 793 /***********************************************************************
 794  * Defines
 795  */
 796
 797 /* flags for NtCreateFile and NtOpenFile */
 798 #define FILE_DIRECTORY_FLAG  0x00000001
 799 #define FILE_WRITE_THROUGH   0x00000002
 800 #define FILE_SEQUENTIAL_ONLY 0x00000004
 801 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
 802 #define FILE_SYNCHRONOUS_IO_ALERT    0x00000010
 803 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
 804 #define FILE_NON_DIRECTORY_FILE      0x00000040
 805 #define FILE_CREATE_TREE_CONNECTION  0x00000080
 806
 807 /* status for NtCreateFile or NtOpenFile */
 808 #define FILE_SUPERSEDED  0x00000000
 809 #define FILE_OPENED      0x00000001
 810 #define FILE_CREATED     0x00000002
 811 #define FILE_OVERWRITTEN 0x00000003
 812 #define FILE_EXISTS      0x00000004
 813 #define FILE_DOES_NOT_EXIST 0x00000005
 814
 815 #if (_WIN32_WINNT >= 0x0501)
 816 #define INTERNAL_TS_ACTIVE_CONSOLE_ID ( *((volatile ULONG*)(0x7ffe02d8)) )
 817 #endif /* (_WIN32_WINNT >= 0x0501) */
 818
 819 #define LOGONID_CURRENT    ((ULONG)-1)
 820
 821 #define OBJ_INHERIT          0x00000002L
 822 #define OBJ_PERMANENT        0x00000010L
 823 #define OBJ_EXCLUSIVE        0x00000020L
 824 #define OBJ_CASE_INSENSITIVE 0x00000040L
 825 #define OBJ_OPENIF           0x00000080L
 826 #define OBJ_OPENLINK         0x00000100L
 827 #define OBJ_KERNEL_HANDLE    0x00000200L
 828 #define OBJ_VALID_ATTRIBUTES 0x000003F2L
 829
 830 #define SERVERNAME_CURRENT ((HANDLE)NULL)
 831
 832 typedef void (CALLBACK *PNTAPCFUNC)(ULONG_PTR,ULONG_PTR,ULONG_PTR); /* FIXME: not the right name */
 833
 834 /***********************************************************************
 835  * Function declarations
 836  */
 837
 838 extern LPSTR _strlwr(LPSTR str); /* FIXME: Doesn't belong here */
 839 extern LPSTR _strupr(LPSTR str); /* FIXME: Doesn't belong here */
 840
 841 #if defined(__i386__) && defined(__GNUC__)
 842 static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
 843 static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
 844 #else  /* __i386__ && __GNUC__ */
 845 void WINAPI DbgBreakPoint(void);
 846 void WINAPI DbgUserBreakPoint(void);
 847 #endif  /* __i386__ && __GNUC__ */
 848 void WINAPIV DbgPrint(LPCSTR fmt, ...);
 849
 850 NTSTATUS  WINAPI LdrAccessResource(HMODULE,const IMAGE_RESOURCE_DATA_ENTRY*,void**,PULONG);
 851 NTSTATUS  WINAPI LdrFindResourceDirectory_U(HMODULE,const LDR_RESOURCE_INFO*,ULONG,const IMAGE_RESOURCE_DIRECTORY**);
 852 NTSTATUS  WINAPI LdrFindResource_U(HMODULE,const LDR_RESOURCE_INFO*,ULONG,const IMAGE_RESOURCE_DATA_ENTRY**);
 853 void      WINAPI LdrShutdownProcess(void);
 854 void      WINAPI LdrShutdownThread(void);
 855 NTSTATUS  WINAPI NtAccessCheck(PSECURITY_DESCRIPTOR,HANDLE,ACCESS_MASK,PGENERIC_MAPPING,PPRIVILEGE_SET,PULONG,PULONG,PBOOLEAN);
 856 NTSTATUS  WINAPI NtAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
 857 NTSTATUS  WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,PVOID,ULONG*,ULONG,ULONG);
 858 NTSTATUS  WINAPI NtClearEvent(HANDLE);
 859 NTSTATUS  WINAPI NtClose(HANDLE);
 860 NTSTATUS  WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
 861 NTSTATUS  WINAPI NtCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
 862 NTSTATUS  WINAPI NtCreateKey(PHKEY,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
 863 NTSTATUS  WINAPI NtCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
 864 NTSTATUS  WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
 865 NTSTATUS  WINAPI NtDeleteKey(HKEY);
 866 NTSTATUS  WINAPI NtDeleteValueKey(HKEY,const UNICODE_STRING *);
 867 NTSTATUS  WINAPI NtDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
 868 NTSTATUS  WINAPI NtDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
 869 NTSTATUS  WINAPI NtEnumerateKey(HKEY,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 870 NTSTATUS  WINAPI NtEnumerateValueKey(HKEY,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 871 NTSTATUS  WINAPI NtFlushBuffersFile(HANDLE,IO_STATUS_BLOCK*);
 872 NTSTATUS  WINAPI NtFlushKey(HKEY);
 873 NTSTATUS  WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,ULONG*,ULONG);
 874 NTSTATUS  WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 875 NTSTATUS  WINAPI NtGetContextThread(HANDLE,CONTEXT*);
 876 NTSTATUS  WINAPI NtLoadKey(const OBJECT_ATTRIBUTES *,const OBJECT_ATTRIBUTES *);
 877 NTSTATUS  WINAPI NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 878 NTSTATUS  WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
 879 NTSTATUS  WINAPI NtNotifyChangeKey(HKEY,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
 880 NTSTATUS  WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 881 NTSTATUS  WINAPI NtOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
 882 NTSTATUS  WINAPI NtOpenKey(PHKEY,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 883 NTSTATUS  WINAPI NtOpenProcessToken(HANDLE,DWORD,HANDLE *);
 884 NTSTATUS  WINAPI NtOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 885 NTSTATUS  WINAPI NtOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
 886 NTSTATUS  WINAPI NtOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
 887 NTSTATUS  WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
 888 NTSTATUS  WINAPI NtPulseEvent(HANDLE,PULONG);
 889 NTSTATUS  WINAPI NtQueueApcThread(HANDLE,PNTAPCFUNC,ULONG_PTR,ULONG_PTR,ULONG_PTR);
 890 NTSTATUS  WINAPI NtQueryDefaultLocale(BOOLEAN,LCID*);
 891 NTSTATUS  WINAPI NtQueryInformationProcess(HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);
 892 NTSTATUS  WINAPI NtQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
 893 NTSTATUS  WINAPI NtQueryInformationToken(HANDLE,DWORD,LPVOID,DWORD,LPDWORD);
 894 NTSTATUS  WINAPI NtQueryKey(HKEY,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 895 NTSTATUS  WINAPI NtQueryMultipleValueKey(HKEY,PVALENTW,ULONG,PVOID,ULONG,PULONG);
 896 NTSTATUS  WINAPI NtQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
 897 NTSTATUS  WINAPI NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 898 NTSTATUS  WINAPI NtQuerySystemTime(PLARGE_INTEGER);
 899 NTSTATUS  WINAPI NtQueryValueKey(HKEY,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
 900 NTSTATUS  WINAPI NtQueryVirtualMemory(HANDLE,LPCVOID,MEMORY_INFORMATION_CLASS,PVOID,ULONG,ULONG*);
 901 void      WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
 902 NTSTATUS  WINAPI NtReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
 903 NTSTATUS  WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
 904 NTSTATUS  WINAPI NtReplaceKey(POBJECT_ATTRIBUTES,HKEY,POBJECT_ATTRIBUTES);
 905 NTSTATUS  WINAPI NtResetEvent(HANDLE,PULONG);
 906 NTSTATUS  WINAPI NtRestoreKey(HKEY,HANDLE,ULONG);
 907 NTSTATUS  WINAPI NtResumeThread(HANDLE,PULONG);
 908 NTSTATUS  WINAPI NtSaveKey(HKEY,HANDLE);
 909 NTSTATUS  WINAPI NtSetContextThread(HANDLE,const CONTEXT*);
 910 NTSTATUS  WINAPI NtSetDefaultLocale(BOOLEAN,LCID);
 911 NTSTATUS  WINAPI NtSetEvent(HANDLE,PULONG);
 912 NTSTATUS  WINAPI NtSetInformationKey(HKEY,const int,PVOID,ULONG);
 913 NTSTATUS  WINAPI NtSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 914 NTSTATUS  WINAPI NtSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
 915 NTSTATUS  WINAPI NtSetValueKey(HKEY,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
 916 NTSTATUS  WINAPI NtSuspendThread(HANDLE,PULONG);
 917 NTSTATUS  WINAPI NtTerminateProcess(HANDLE,LONG);
 918 NTSTATUS  WINAPI NtTerminateThread(HANDLE,LONG);
 919 NTSTATUS  WINAPI NtUnloadKey(HKEY);
 920 NTSTATUS  WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 921 NTSTATUS  WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
 922 NTSTATUS  WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,PLARGE_INTEGER);
 923 NTSTATUS  WINAPI NtWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,PLARGE_INTEGER);
 924
 925 void      WINAPI RtlAcquirePebLock(void);
 926 BYTE      WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK,BYTE);
 927 BYTE      WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK,BYTE);
 928 NTSTATUS  WINAPI RtlAddAce(PACL,DWORD,DWORD,PACE_HEADER,DWORD);
 929 NTSTATUS  WINAPI RtlAddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
 930 BOOL      WINAPI RtlAddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
 931 NTSTATUS  WINAPI RtlAddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
 932 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
 933 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
 934 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
 935 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
 936 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
 937 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
 938 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
 939 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
 940 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
 941 BOOLEAN   WINAPI RtlAreAllAccessesGranted(ACCESS_MASK,ACCESS_MASK);
 942 BOOLEAN   WINAPI RtlAreAnyAccessesGranted(ACCESS_MASK,ACCESS_MASK);
 943 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
 944 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
 945
 946 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
 947 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
 948 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
 949 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
 950 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
 951 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 952 DWORD     WINAPI RtlComputeCrc32(DWORD,PBYTE,INT);
 953 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
 954 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
 955 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
 956 void      WINAPI RtlCopyLuid(PLUID,const LUID*);
 957 void      WINAPI RtlCopyLuidAndAttributesArray(ULONG,const LUID_AND_ATTRIBUTES*,PLUID_AND_ATTRIBUTES);
 958 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
 959 void      WINAPI RtlCopyString(STRING*,const STRING*);
 960 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
 961 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
 962 NTSTATUS  WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
 963 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
 964 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
 965 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
 966 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
 967
 968 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
 969 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
 970 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
 971 NTSTATUS  WINAPI RtlDestroyEnvironment(PWSTR);
 972 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
 973 DOS_PATHNAME_TYPE WINAPI RtlDetermineDosPathNameType_U(PCWSTR);
 974 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(LPWSTR,PUNICODE_STRING,PWSTR*,CURDIR*);
 975 WCHAR     WINAPI RtlDowncaseUnicodeChar(WCHAR);
 976 NTSTATUS  WINAPI RtlDowncaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 977 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
 978 NTSTATUS  WINAPI RtlDuplicateUnicodeString(int,const UNICODE_STRING*,UNICODE_STRING*);
 979
 980 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
 981 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
 982 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
 983 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
 984 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
 985 NTSTATUS  WINAPI RtlEqualComputerName(const UNICODE_STRING*,const UNICODE_STRING*);
 986 NTSTATUS  WINAPI RtlEqualDomainName(const UNICODE_STRING*,const UNICODE_STRING*);
 987 BOOLEAN   WINAPI RtlEqualLuid(const LUID*,const LUID*);
 988 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
 989 BOOL      WINAPI RtlEqualSid(PSID,PSID);
 990 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
 991 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 992 NTSTATUS  WINAPI RtlExpandEnvironmentStrings_U(PWSTR, const UNICODE_STRING*, UNICODE_STRING*, ULONG*);
 993 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
 994 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
 995 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
 996
 997 NTSTATUS  WINAPI RtlFindCharInUnicodeString(int,const UNICODE_STRING*,const UNICODE_STRING*,USHORT*);
 998 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
 999 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
1000 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1001 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1002 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1003 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
1004 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
1005 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
1006 NTSTATUS  WINAPI RtlFindMessage(HMODULE,ULONG,ULONG,ULONG,const MESSAGE_RESOURCE_ENTRY**);
1007 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
1008 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1009 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1010 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
1011 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
1012 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1013 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
1014 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
1015 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
1016 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
1017 void      WINAPI RtlFreeOemString(POEM_STRING);
1018 DWORD     WINAPI RtlFreeSid(PSID);
1019 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
1020
1021 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
1022 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
1023 NTSTATUS  WINAPI RtlGetCurrentDirectory_U(ULONG, LPWSTR);
1024 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1025 ULONG     WINAPI RtlGetFullPathName_U(PCWSTR,ULONG,PWSTR,PWSTR*);
1026 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1027 DWORD     WINAPI RtlGetLongestNtPathLength(void);
1028 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
1029 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1030 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
1031 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1032
1033 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
1034 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
1035 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
1036 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
1037 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
1038 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
1039 void      WINAPI RtlInitString(PSTRING,PCSZ);
1040 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
1041 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
1042 NTSTATUS  WINAPI RtlInitUnicodeStringEx(PUNICODE_STRING,PCWSTR);
1043 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
1044 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
1045 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1046 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
1047 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
1048
1049 NTSTATUS  WINAPI RtlInt64ToUnicodeString(ULONGLONG,ULONG,UNICODE_STRING *);
1050 NTSTATUS  WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
1051 NTSTATUS  WINAPI RtlIntegerToUnicodeString(ULONG,ULONG,UNICODE_STRING *);
1052 ULONG     WINAPI RtlIsDosDeviceName_U(PCWSTR);
1053 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
1054 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
1055
1056 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
1057 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
1058 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
1059 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
1060 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
1061 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
1062 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
1063 NTSTATUS  WINAPI RtlLargeIntegerToChar(const ULONGLONG *,ULONG,ULONG,PCHAR);
1064 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
1065 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
1066 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
1067 DWORD     WINAPI RtlLengthSid(PSID);
1068 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1069 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
1070
1071 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
1072 void      WINAPI RtlMapGenericMask(PACCESS_MASK,const GENERIC_MAPPING*);
1073 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1074 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
1075
1076 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
1077 LPVOID    WINAPI RtlNormalizeProcessParams(LPVOID);
1078 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
1079 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1080 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1081
1082 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
1083 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
1084 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1085 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHKEY);
1086
1087 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
1088 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1089
1090 NTSTATUS  WINAPI RtlQueryEnvironmentVariable_U(PWSTR,PUNICODE_STRING,PUNICODE_STRING);
1091 NTSTATUS  WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1092
1093 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
1094 void      WINAPI RtlRaiseStatus(NTSTATUS);
1095 ULONG     WINAPI RtlRandom(PULONG);
1096 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
1097 void      WINAPI RtlReleasePebLock(void);
1098 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
1099
1100 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
1101 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
1102 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
1103 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1104 NTSTATUS  WINAPI RtlSetCurrentDirectory_U(const UNICODE_STRING*);
1105 void      WINAPI RtlSetCurrentEnvironment(PWSTR, PWSTR*);
1106 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1107 NTSTATUS  WINAPI RtlSetEnvironmentVariable(PWSTR*,PUNICODE_STRING,PUNICODE_STRING);
1108 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1109 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1110 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1111 NTSTATUS  WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
1112 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
1113 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
1114 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
1115 NTSTATUS  WINAPI RtlSystemTimeToLocalTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1116
1117 void      WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
1118 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
1119 void      WINAPI RtlTimeToElapsedTimeFields(const LARGE_INTEGER *,PTIME_FIELDS);
1120 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,PULONG);
1121 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
1122 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
1123
1124 ULONGLONG __cdecl RtlUlonglongByteSwap(ULONGLONG);
1125 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
1126 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
1127 NTSTATUS  WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING *,ULONG,ULONG *);
1128 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
1129 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
1130 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1131 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
1132 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1133 ULONG     WINAPI RtlUniform(PULONG);
1134 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
1135 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
1136 #ifdef __ia64__
1137 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
1138 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1139 #endif
1140 WCHAR     WINAPI RtlUpcaseUnicodeChar(WCHAR);
1141 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1142 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1143 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToCountedOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1144 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1145 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1146 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1147 CHAR      WINAPI RtlUpperChar(CHAR);
1148 void      WINAPI RtlUpperString(STRING *,const STRING *);
1149
1150 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1151 BOOLEAN   WINAPI RtlValidAcl(PACL);
1152 BOOLEAN   WINAPI RtlValidSid(PSID);
1153 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1154
1155 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1156
1157 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1158 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1159
1160 /***********************************************************************
1161  * Inline functions
1162  */
1163
1164 #define InitializeObjectAttributes(p,n,a,r,s) \
1165     do { \
1166         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1167         (p)->RootDirectory = r; \
1168         (p)->Attributes = a; \
1169         (p)->ObjectName = n; \
1170         (p)->SecurityDescriptor = s; \
1171         (p)->SecurityQualityOfService = NULL; \
1172     } while (0)
1173
1174 #define NtCurrentProcess() ((HANDLE)-1)
1175
1176 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1177 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1178 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1179 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1180 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1181 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1182 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1183
1184 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1185 {
1186     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1187         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1188         return TRUE;
1189     return FALSE;
1190 }
1191
1192 #define RtlClearAllBits(p) \
1193     do { \
1194         PRTL_BITMAP _p = (p); \
1195         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1196     } while (0)
1197
1198 #define RtlInitializeBitMap(p,b,s) \
1199     do { \
1200         PRTL_BITMAP _p = (p); \
1201         _p->SizeOfBitMap = (s); \
1202         _p->BitMapBuffer = (b); \
1203     } while (0)
1204
1205 #define RtlSetAllBits(p) \
1206     do { \
1207         PRTL_BITMAP _p = (p); \
1208         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1209     } while (0)
1210
1211 /* These are implemented as __fastcall, so we can't let Winelib apps link with them */
1212 inline static USHORT RtlUshortByteSwap(USHORT s)
1213 {
1214     return (s >> 8) | (s << 8);
1215 }
1216 inline static ULONG RtlUlongByteSwap(ULONG i)
1217 {
1218 #if defined(__i386__) && defined(__GNUC__)
1219     ULONG ret;
1220     __asm__("bswap %0" : "=r" (ret) : "0" (i) );
1221     return ret;
1222 #else
1223     return ((ULONG)RtlUshortByteSwap(i) << 16) | RtlUshortByteSwap(i >> 16);
1224 #endif
1225 }
1226
1227 /*************************************************************************
1228  * Loader functions and structures.
1229  *
1230  * Those are not part of standard Winternl.h
1231  */
1232 typedef struct _LDR_MODULE
1233 {
1234     LIST_ENTRY          InLoadOrderModuleList;
1235     LIST_ENTRY          InMemoryOrderModuleList;
1236     LIST_ENTRY          InInitializationOrderModuleList;
1237     void*               BaseAddress;
1238     void*               EntryPoint;
1239     ULONG               SizeOfImage;
1240     UNICODE_STRING      FullDllName;
1241     UNICODE_STRING      BaseDllName;
1242     ULONG               Flags;
1243     SHORT               LoadCount;
1244     SHORT               TlsIndex;
1245     HANDLE              SectionHandle;
1246     ULONG               CheckSum;
1247     ULONG               TimeDateStamp;
1248 } LDR_MODULE, *PLDR_MODULE;
1249
1250 /* those defines are (some of the) regular LDR_MODULE.Flags values */
1251 #define LDR_IMAGE_IS_DLL                0x00000004
1252 #define LDR_LOAD_IN_PROGRESS            0x00001000
1253 #define LDR_UNLOAD_IN_PROGRESS          0x00002000
1254 #define LDR_NO_DLL_CALLS                0x00040000
1255 #define LDR_PROCESS_ATTACHED            0x00080000
1256 #define LDR_MODULE_REBASED              0x00200000
1257
1258 /* these ones is Wine specific */
1259 #define LDR_DONT_RESOLVE_REFS           0x40000000
1260 #define LDR_WINE_INTERNAL               0x80000000
1261
1262 /* FIXME: to be checked */
1263 #define MAXIMUM_FILENAME_LENGTH 256
1264
1265 typedef struct _SYSTEM_MODULE
1266 {
1267     ULONG               Reserved1;
1268     ULONG               Reserved2;
1269     PVOID               ImageBaseAddress;
1270     ULONG               ImageSize;
1271     ULONG               Flags;
1272     WORD                Id;
1273     WORD                Rank;
1274     WORD                Unknown;
1275     WORD                NameOffset;
1276     BYTE                Name[MAXIMUM_FILENAME_LENGTH];
1277 } SYSTEM_MODULE, *PSYSTEM_MODULE;
1278
1279 typedef struct _SYSTEM_MODULE_INFORMATION
1280 {
1281     ULONG               ModulesCount;
1282     SYSTEM_MODULE       Modules[1]; /* FIXME: should be Modules[0] */
1283 } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
1284
1285 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE);
1286 NTSTATUS WINAPI LdrFindEntryForAddress(const void*, PLDR_MODULE*);
1287 NTSTATUS WINAPI LdrGetDllHandle(ULONG, ULONG, PUNICODE_STRING, HMODULE*);
1288 NTSTATUS WINAPI LdrGetProcedureAddress(HMODULE, PANSI_STRING, ULONG, void**);
1289 NTSTATUS WINAPI LdrLoadDll(LPCWSTR, DWORD, PUNICODE_STRING, HMODULE*);
1290 NTSTATUS WINAPI LdrLockLoaderLock(ULONG,ULONG*,ULONG*);
1291 NTSTATUS WINAPI LdrQueryProcessModuleInformation(SYSTEM_MODULE_INFORMATION*, ULONG, ULONG*);
1292 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
1293 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
1294
1295 #ifdef __cplusplus
1296 } /* extern "C" */
1297 #endif /* defined(__cplusplus) */
1298
1299 #endif  /* __WINE_WINTERNAL_H */