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