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