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