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
 876 void      WINAPI RtlAcquirePebLock(void);
 877 BYTE      WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK,BYTE);
 878 BYTE      WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK,BYTE);
 879 NTSTATUS  WINAPI RtlAddAce(PACL,DWORD,DWORD,PACE_HEADER,DWORD);
 880 BOOL      WINAPI RtlAddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
 881 BOOL      WINAPI RtlAddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
 882 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
 883 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
 884 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
 885 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
 886 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
 887 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
 888 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
 889 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
 890 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
 891 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
 892 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
 893
 894 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
 895 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
 896 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
 897 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
 898 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
 899 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 900 DWORD     WINAPI RtlComputeCrc32(DWORD,PBYTE,INT);
 901 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
 902 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
 903 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
 904 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
 905 void      WINAPI RtlCopyString(STRING*,const STRING*);
 906 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
 907 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
 908 DWORD     WINAPI RtlCreateEnvironment(DWORD,DWORD);
 909 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
 910 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
 911 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
 912 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
 913
 914 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
 915 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
 916 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
 917 DWORD     WINAPI RtlDestroyEnvironment(DWORD);
 918 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
 919 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(LPWSTR,PUNICODE_STRING,DWORD,DWORD);
 920 WCHAR     WINAPI RtlDowncaseUnicodeChar(WCHAR);
 921 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
 922
 923 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
 924 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
 925 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
 926 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
 927 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
 928 NTSTATUS  WINAPI RtlEqualComputerName(const UNICODE_STRING*,const UNICODE_STRING*);
 929 NTSTATUS  WINAPI RtlEqualDomainName(const UNICODE_STRING*,const UNICODE_STRING*);
 930 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
 931 BOOL      WINAPI RtlEqualSid(PSID,PSID);
 932 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
 933 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 934 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
 935 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
 936 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
 937
 938 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
 939 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
 940 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
 941 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
 942 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
 943 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
 944 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
 945 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
 946 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
 947 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
 948 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
 949 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
 950 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
 951 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
 952 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
 953 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
 954 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
 955 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
 956 void      WINAPI RtlFreeOemString(POEM_STRING);
 957 DWORD     WINAPI RtlFreeSid(PSID);
 958 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
 959
 960 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
 961 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
 962 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
 963 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
 964 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
 965 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
 966 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
 967 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
 968
 969 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
 970 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
 971 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
 972 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
 973 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
 974 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
 975 void      WINAPI RtlInitString(PSTRING,PCSZ);
 976 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
 977 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
 978 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
 979 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
 980 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
 981 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
 982 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
 983
 984 NTSTATUS  WINAPI RtlInt64ToUnicodeString(ULONGLONG,ULONG,UNICODE_STRING *);
 985 NTSTATUS  WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
 986 NTSTATUS  WINAPI RtlIntegerToUnicodeString(ULONG,ULONG,UNICODE_STRING *);
 987 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(PUNICODE_STRING,POEM_STRING,PBOOLEAN);
 988 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
 989
 990 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
 991 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
 992 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
 993 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
 994 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
 995 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
 996 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
 997 NTSTATUS  WINAPI RtlLargeIntegerToChar(const ULONGLONG *,ULONG,ULONG,PCHAR);
 998 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
 999 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
1000 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
1001 DWORD     WINAPI RtlLengthSid(PSID);
1002 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1003 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
1004
1005 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
1006 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1007 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
1008
1009 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
1010 LPVOID    WINAPI RtlNormalizeProcessParams(LPVOID);
1011 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
1012 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1013 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1014
1015 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
1016 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
1017 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1018 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHKEY);
1019
1020 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
1021 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1022
1023 DWORD     WINAPI RtlQueryEnvironmentVariable_U(DWORD,PUNICODE_STRING,PUNICODE_STRING) ;
1024 NTSTATUS  WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1025 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
1026 void      WINAPI RtlRaiseStatus(NTSTATUS);
1027 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
1028 void      WINAPI RtlReleasePebLock(void);
1029 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
1030
1031 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
1032 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
1033 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
1034 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1035 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1036 DWORD     WINAPI RtlSetEnvironmentVariable(DWORD,PUNICODE_STRING,PUNICODE_STRING);
1037 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1038 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1039 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1040 NTSTATUS  WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
1041 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
1042 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
1043 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
1044 NTSTATUS  WINAPI RtlSystemTimeToLocalTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1045
1046 void      WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
1047 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
1048 void      WINAPI RtlTimeToElapsedTimeFields(const LARGE_INTEGER *,PTIME_FIELDS);
1049 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,PULONG);
1050 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
1051 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
1052
1053 ULONGLONG __cdecl RtlUlonglongByteSwap(ULONGLONG);
1054 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
1055 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
1056 NTSTATUS  WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING *,ULONG,ULONG *);
1057 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
1058 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
1059 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1060 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
1061 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1062 ULONG     WINAPI RtlUniform(PULONG);
1063 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
1064 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
1065 #ifdef __ia64__
1066 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
1067 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1068 #endif
1069 WCHAR     WINAPI RtlUpcaseUnicodeChar(WCHAR);
1070 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1071 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1072 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1073 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1074 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1075 CHAR      WINAPI RtlUpperChar(CHAR);
1076 void      WINAPI RtlUpperString(STRING *,const STRING *);
1077
1078 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1079 BOOL      WINAPI RtlValidSid(PSID);
1080 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1081
1082 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1083
1084 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1085 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1086
1087 /***********************************************************************
1088  * Inline functions
1089  */
1090
1091 #define InitializeObjectAttributes(p,n,a,r,s) \
1092     do { \
1093         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1094         (p)->RootDirectory = r; \
1095         (p)->Attributes = a; \
1096         (p)->ObjectName = n; \
1097         (p)->SecurityDescriptor = s; \
1098         (p)->SecurityQualityOfService = NULL; \
1099     } while (0)
1100
1101 #define NtCurrentProcess() ((HANDLE)-1)
1102
1103 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1104 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1105 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1106 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1107 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1108 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1109 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1110
1111 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1112 {
1113     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1114         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1115         return TRUE;
1116     return FALSE;
1117 }
1118
1119 #define RtlClearAllBits(p) \
1120     do { \
1121         PRTL_BITMAP _p = (p); \
1122         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1123     } while (0)
1124
1125 #define RtlInitializeBitMap(p,b,s) \
1126     do { \
1127         PRTL_BITMAP _p = (p); \
1128         _p->SizeOfBitMap = (s); \
1129         _p->BitMapBuffer = (b); \
1130     } while (0)
1131
1132 #define RtlSetAllBits(p) \
1133     do { \
1134         PRTL_BITMAP _p = (p); \
1135         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1136     } while (0)
1137
1138 /* These are implemented as __fastcall, so we can't let Winelib apps link with them */
1139 inline static USHORT RtlUshortByteSwap(USHORT s)
1140 {
1141     return (s >> 8) | (s << 8);
1142 }
1143 inline static ULONG RtlUlongByteSwap(ULONG i)
1144 {
1145 #if defined(__i386__) && defined(__GNUC__)
1146     ULONG ret;
1147     __asm__("bswap %0" : "=r" (ret) : "0" (i) );
1148     return ret;
1149 #else
1150     return ((ULONG)RtlUshortByteSwap(i) << 16) | RtlUshortByteSwap(i >> 16);
1151 #endif
1152 }
1153
1154 /*************************************************************************
1155  * Loader functions and structures.
1156  *
1157  * Those are not part of standard Winternl.h
1158  */
1159 typedef struct _LDR_MODULE
1160 {
1161     LIST_ENTRY          InLoadOrderModuleList;
1162     LIST_ENTRY          InMemoryOrderModuleList;
1163     LIST_ENTRY          InInitializationOrderModuleList;
1164     void*               BaseAddress;
1165     void*               EntryPoint;
1166     ULONG               SizeOfImage;
1167     UNICODE_STRING      FullDllName;
1168     UNICODE_STRING      BaseDllName;
1169     ULONG               Flags;
1170     SHORT               LoadCount;
1171     SHORT               TlsIndex;
1172     HANDLE              SectionHandle;
1173     ULONG               CheckSum;
1174     ULONG               TimeDateStamp;
1175 } LDR_MODULE, *PLDR_MODULE;
1176
1177 /* those defines are (some of the) regular LDR_MODULE.Flags values */
1178 #define LDR_IMAGE_IS_DLL                0x00000004
1179 #define LDR_LOAD_IN_PROGRESS            0x00001000
1180 #define LDR_UNLOAD_IN_PROGRESS          0x00002000
1181 #define LDR_NO_DLL_CALLS                0x00040000
1182 #define LDR_PROCESS_ATTACHED            0x00080000
1183 #define LDR_MODULE_REBASED              0x00200000
1184
1185 /* these ones is Wine specific */
1186 #define LDR_DONT_RESOLVE_REFS           0x40000000
1187 #define LDR_WINE_INTERNAL               0x80000000
1188
1189 /* FIXME: to be checked */
1190 #define MAXIMUM_FILENAME_LENGTH 256
1191
1192 typedef struct _SYSTEM_MODULE
1193 {
1194     ULONG               Reserved1;
1195     ULONG               Reserved2;
1196     PVOID               ImageBaseAddress;
1197     ULONG               ImageSize;
1198     ULONG               Flags;
1199     WORD                Id;
1200     WORD                Rank;
1201     WORD                Unknown;
1202     WORD                NameOffset;
1203     BYTE                Name[MAXIMUM_FILENAME_LENGTH];
1204 } SYSTEM_MODULE, *PSYSTEM_MODULE;
1205
1206 typedef struct _SYSTEM_MODULE_INFORMATION
1207 {
1208     ULONG               ModulesCount;
1209     SYSTEM_MODULE       Modules[1]; /* FIXME: should be Modules[0] */
1210 } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
1211
1212 typedef struct _LDR_RESOURCE_INFO
1213 {
1214     ULONG               Type;
1215     ULONG               Name;
1216     ULONG               Language;
1217 } LDR_RESOURCE_INFO, *PLDR_RESOURCE_INFO;
1218
1219 NTSTATUS WINAPI LdrAccessResource(HMODULE, PIMAGE_RESOURCE_DATA_ENTRY, void**, PULONG);
1220 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE);
1221 NTSTATUS WINAPI LdrFindEntryForAddress(const void*, PLDR_MODULE*);
1222 NTSTATUS WINAPI LdrFindResourceDirectory_U(HMODULE,PLDR_RESOURCE_INFO, DWORD,
1223                                            PIMAGE_RESOURCE_DIRECTORY_ENTRY*);
1224 NTSTATUS WINAPI LdrFindResource_U(HMODULE, PLDR_RESOURCE_INFO, ULONG,
1225                                   PIMAGE_RESOURCE_DATA_ENTRY*);
1226 NTSTATUS WINAPI LdrGetDllHandle(ULONG, ULONG, PUNICODE_STRING, HMODULE*);
1227 NTSTATUS WINAPI LdrGetProcedureAddress(HMODULE, PANSI_STRING, ULONG, void**);
1228 NTSTATUS WINAPI LdrLoadDll(LPCWSTR, DWORD, PUNICODE_STRING, HMODULE*);
1229 NTSTATUS WINAPI LdrLockLoaderLock(ULONG,ULONG*,ULONG*);
1230 NTSTATUS WINAPI LdrQueryProcessModuleInformation(SYSTEM_MODULE_INFORMATION*, ULONG, ULONG*);
1231 NTSTATUS WINAPI LdrShutdownProcess(void);
1232 NTSTATUS WINAPI LdrShutdownThread(void);
1233 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
1234 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
1235
1236 #ifdef __cplusplus
1237 } /* extern "C" */
1238 #endif /* defined(__cplusplus) */
1239
1240 #endif  /* __WINE_WINTERNAL_H */