include/winternl.h

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