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
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif /* defined(__cplusplus) */
  29
  30
  31 /**********************************************************************
  32  * Fundamental types and data structures
  33  */
  34
  35 typedef LONG NTSTATUS;
  36
  37 typedef CONST char *PCSZ;
  38
  39 typedef short CSHORT;
  40 typedef CSHORT *PCSHORT;
  41
  42 typedef struct _STRING {
  43   USHORT Length;
  44   USHORT MaximumLength;
  45   PCHAR Buffer;
  46 } STRING, *PSTRING;
  47
  48 typedef STRING ANSI_STRING;
  49 typedef PSTRING PANSI_STRING;
  50 typedef const STRING *PCANSI_STRING;
  51
  52 typedef STRING OEM_STRING;
  53 typedef PSTRING POEM_STRING;
  54 typedef const STRING *PCOEM_STRING;
  55
  56 typedef struct _UNICODE_STRING {
  57   USHORT Length;        /* bytes */
  58   USHORT MaximumLength; /* bytes */
  59   PWSTR  Buffer;
  60 } UNICODE_STRING, *PUNICODE_STRING;
  61
  62 typedef const UNICODE_STRING *PCUNICODE_STRING;
  63
  64 typedef struct _CLIENT_ID
  65 {
  66    HANDLE UniqueProcess;
  67    HANDLE UniqueThread;
  68 } CLIENT_ID, *PCLIENT_ID;
  69
  70 typedef struct _CURDIR
  71 {
  72     UNICODE_STRING DosPath;
  73     PVOID Handle;
  74 } CURDIR, *PCURDIR;
  75
  76 typedef struct RTL_DRIVE_LETTER_CURDIR
  77 {
  78     USHORT              Flags;
  79     USHORT              Length;
  80     ULONG               TimeStamp;
  81     UNICODE_STRING      DosPath;
  82 } RTL_DRIVE_LETTER_CURDIR, *PRTL_DRIVE_LETTER_CURDIR;
  83
  84 typedef struct tagRTL_BITMAP {
  85     ULONG  SizeOfBitMap; /* Number of bits in the bitmap */
  86     LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */
  87 } RTL_BITMAP, *PRTL_BITMAP;
  88
  89 typedef const RTL_BITMAP *PCRTL_BITMAP;
  90
  91 typedef struct tagRTL_BITMAP_RUN {
  92     ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */
  93     ULONG SizeOfRun;  /* Size of the run in bits - FIXME: Name? */
  94 } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
  95
  96 typedef const RTL_BITMAP_RUN *PCRTL_BITMAP_RUN;
  97
  98 typedef struct _RTL_USER_PROCESS_PARAMETERS
  99 {
 100     ULONG               AllocationSize;
 101     ULONG               Size;
 102     ULONG               Flags;
 103     ULONG               DebugFlags;
 104     HANDLE              hConsole;
 105     ULONG               ProcessGroup;
 106     HANDLE              hStdInput;
 107     HANDLE              hStdOutput;
 108     HANDLE              hStdError;
 109     CURDIR              CurrentDirectory;
 110     UNICODE_STRING      DllPath;
 111     UNICODE_STRING      ImagePathName;
 112     UNICODE_STRING      CommandLine;
 113     PWSTR               Environment;
 114     ULONG               dwX;
 115     ULONG               dwY;
 116     ULONG               dwXSize;
 117     ULONG               dwYSize;
 118     ULONG               dwXCountChars;
 119     ULONG               dwYCountChars;
 120     ULONG               dwFillAttribute;
 121     ULONG               dwFlags;
 122     ULONG               wShowWindow;
 123     UNICODE_STRING      WindowTitle;
 124     UNICODE_STRING      Desktop;
 125     UNICODE_STRING      ShellInfo;
 126     UNICODE_STRING      RuntimeInfo;
 127     RTL_DRIVE_LETTER_CURDIR DLCurrentDirectory[0x20];
 128 } RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
 129
 130 /* value for Flags field (FIXME: not the correct name) */
 131 #define PROCESS_PARAMS_FLAG_NORMALIZED 1
 132
 133 typedef struct _PEB_LDR_DATA
 134 {
 135     ULONG               Length;
 136     BOOLEAN             Initialized;
 137     PVOID               SsHandle;
 138     LIST_ENTRY          InLoadOrderModuleList;
 139     LIST_ENTRY          InMemoryOrderModuleList;
 140     LIST_ENTRY          InInitializationOrderModuleList;
 141 } PEB_LDR_DATA, *PPEB_LDR_DATA;
 142
 143 /***********************************************************************
 144  * PEB data structure
 145  */
 146 typedef struct _PEB
 147 {
 148     BYTE                         Reserved1[2];       /*  00 */
 149     BYTE                         BeingDebugged;      /*  02 */
 150     BYTE                         Reserved2[5];       /*  03 */
 151     HMODULE                      ImageBaseAddress;   /*  08 */
 152     PPEB_LDR_DATA                LdrData;            /*  0c */
 153     RTL_USER_PROCESS_PARAMETERS *ProcessParameters;  /*  10 */
 154     PVOID                        __pad_14;           /*  14 */
 155     HANDLE                       ProcessHeap;        /*  18 */
 156     BYTE                         __pad_1c[36];       /*  1c */
 157     PRTL_BITMAP                  TlsBitmap;          /*  40 */
 158     ULONG                        TlsBitmapBits[2];   /*  44 */
 159     BYTE                         __pad_4c[156];      /*  4c */
 160     PVOID                        Reserved3[59];      /*  e8 */
 161     ULONG                        SessionId;          /* 1d4 */
 162 } PEB, *PPEB;
 163
 164
 165 /***********************************************************************
 166  * TEB data structure
 167  */
 168 #if defined(_NTSYSTEM_) || defined(_KERNEL32_)  /* hack, should go away */
 169 # define WINE_NO_TEB
 170 #endif
 171
 172 #ifndef WINE_NO_TEB  /* don't define TEB if included from thread.h */
 173 # ifndef WINE_TEB_DEFINED
 174 # define WINE_TEB_DEFINED
 175 typedef struct _TEB
 176 {
 177     NT_TIB          Tib;                        /* 000 */
 178     PVOID           EnvironmentPointer;         /* 01c */
 179     CLIENT_ID       ClientId;                   /* 020 */
 180     PVOID           ActiveRpcHandle;            /* 028 */
 181     PVOID           ThreadLocalStoragePointer;  /* 02c */
 182     PPEB            Peb;                        /* 030 */
 183     ULONG           LastErrorValue;             /* 034 */
 184     BYTE            __pad038[140];              /* 038 */
 185     ULONG           CurrentLocale;              /* 0c4 */
 186     BYTE            __pad0c8[1752];             /* 0c8 */
 187     PVOID           Reserved2[278];             /* 7a0 */
 188     UNICODE_STRING  StaticUnicodeString;        /* bf8 used by advapi32 */
 189     WCHAR           StaticUnicodeBuffer[261];   /* c00 used by advapi32 */
 190     PVOID           DeallocationStack;          /* e0c */
 191     PVOID           TlsSlots[64];               /* e10 */
 192     LIST_ENTRY      TlsLinks;                   /* f10 */
 193     PVOID           Reserved4[26];              /* f18 */
 194     PVOID           ReservedForOle;             /* f80 Windows 2000 only */
 195     PVOID           Reserved5[4];               /* f84 */
 196     PVOID           TlsExpansionSlots;          /* f94 */
 197 } TEB, *PTEB;
 198 # endif /* WINE_TEB_DEFINED */
 199 #endif  /* WINE_NO_TEB */
 200
 201 /***********************************************************************
 202  * Enums
 203  */
 204
 205 typedef enum _FILE_INFORMATION_CLASS {
 206     FileDirectoryInformation = 1,
 207     FileFullDirectoryInformation,
 208     FileBothDirectoryInformation,
 209     FileBasicInformation,
 210     FileStandardInformation,
 211     FileInternalInformation,
 212     FileEaInformation,
 213     FileAccessInformation,
 214     FileNameInformation,
 215     FileRenameInformation,
 216     FileLinkInformation,
 217     FileNamesInformation,
 218     FileDispositionInformation,
 219     FilePositionInformation,
 220     FileFullEaInformation,
 221     FileModeInformation,
 222     FileAlignmentInformation,
 223     FileAllInformation,
 224     FileAllocationInformation,
 225     FileEndOfFileInformation,
 226     FileAlternateNameInformation,
 227     FileStreamInformation,
 228     FilePipeInformation,
 229     FilePipeLocalInformation,
 230     FilePipeRemoteInformation,
 231     FileMailslotQueryInformation,
 232     FileMailslotSetInformation,
 233     FileCompressionInformation,
 234     FileObjectIdInformation,
 235     FileCompletionInformation,
 236     FileMoveClusterInformation,
 237     FileQuotaInformation,
 238     FileReparsePointInformation,
 239     FileNetworkOpenInformation,
 240     FileAttributeTagInformation,
 241     FileTrackingInformation,
 242     FileMaximumInformation
 243 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
 244
 245 typedef struct _FILE_DIRECTORY_INFORMATION {
 246     ULONG               NextEntryOffset;
 247     ULONG               FileIndex;
 248     LARGE_INTEGER       CreationTime;
 249     LARGE_INTEGER       LastAccessTime;
 250     LARGE_INTEGER       LastWriteTime;
 251     LARGE_INTEGER       ChangeTime;
 252     LARGE_INTEGER       EndOfFile;
 253     LARGE_INTEGER       AllocationSize;
 254     ULONG               FileAttributes;
 255     ULONG               FileNameLength;
 256     WCHAR               FileName[ANYSIZE_ARRAY];
 257 } FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION;
 258
 259 typedef struct _FILE_FULL_DIRECTORY_INFORMATION {
 260     ULONG               NextEntryOffset;
 261     ULONG               FileIndex;
 262     LARGE_INTEGER       CreationTime;
 263     LARGE_INTEGER       LastAccessTime;
 264     LARGE_INTEGER       LastWriteTime;
 265     LARGE_INTEGER       ChangeTime;
 266     LARGE_INTEGER       EndOfFile;
 267     LARGE_INTEGER       AllocationSize;
 268     ULONG               FileAttributes;
 269     ULONG               FileNameLength;
 270     ULONG               EaSize;
 271     WCHAR               FileName[ANYSIZE_ARRAY];
 272 } FILE_FULL_DIRECTORY_INFORMATION, *PFILE_FULL_DIRECTORY_INFORMATION,
 273   FILE_FULL_DIR_INFORMATION, *PFILE_FULL_DIR_INFORMATION;
 274
 275 typedef struct _FILE_BOTH_DIRECTORY_INFORMATION {
 276     ULONG               NextEntryOffset;
 277     ULONG               FileIndex;
 278     LARGE_INTEGER       CreationTime;
 279     LARGE_INTEGER       LastAccessTime;
 280     LARGE_INTEGER       LastWriteTime;
 281     LARGE_INTEGER       ChangeTime;
 282     LARGE_INTEGER       EndOfFile;
 283     LARGE_INTEGER       AllocationSize;
 284     ULONG               FileAttributes;
 285     ULONG               FileNameLength;
 286     ULONG               EaSize;
 287     CHAR                ShortNameLength;
 288     WCHAR               ShortName[12];
 289     WCHAR               FileName[ANYSIZE_ARRAY];
 290 } FILE_BOTH_DIRECTORY_INFORMATION, *PFILE_BOTH_DIRECTORY_INFORMATION,
 291   FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION;
 292
 293 typedef struct _FILE_BASIC_INFORMATION {
 294     LARGE_INTEGER CreationTime;
 295     LARGE_INTEGER LastAccessTime;
 296     LARGE_INTEGER LastWriteTime;
 297     LARGE_INTEGER ChangeTime;
 298     ULONG FileAttributes;
 299 } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
 300
 301 typedef struct _FILE_STANDARD_INFORMATION {
 302     LARGE_INTEGER AllocationSize;
 303     LARGE_INTEGER EndOfFile;
 304     ULONG NumberOfLinks;
 305     BOOLEAN DeletePending;
 306     BOOLEAN Directory;
 307 } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
 308
 309 typedef struct _FILE_POSITION_INFORMATION {
 310     LARGE_INTEGER CurrentByteOffset;
 311 } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
 312
 313 typedef struct _FILE_ALIGNMENT_INFORMATION {
 314     ULONG AlignmentRequirement;
 315 } FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
 316
 317 typedef struct _FILE_NETWORK_OPEN_INFORMATION {
 318     LARGE_INTEGER CreationTime;
 319     LARGE_INTEGER LastAccessTime;
 320     LARGE_INTEGER LastWriteTime;
 321     LARGE_INTEGER ChangeTime;
 322     LARGE_INTEGER AllocationSize;
 323     LARGE_INTEGER EndOfFile;
 324     ULONG FileAttributes;
 325 } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
 326
 327 typedef struct _FILE_FULL_EA_INFORMATION {
 328     ULONG NextEntryOffset;
 329     UCHAR Flags;
 330     UCHAR EaNameLength;
 331     USHORT EaValueLength;
 332     CHAR EaName[1];
 333 } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
 334
 335 typedef struct _FILE_STREAM_INFORMATION
 336 {
 337     ULONG NextEntryOffset;
 338     ULONG StreamNameLength;
 339     LARGE_INTEGER StreamSize;
 340     LARGE_INTEGER StreamAllocationSize;
 341     WCHAR StreamName[1];
 342 } FILE_STREAM_INFORMATION, *PFILE_STREAM_INFORMATION;
 343
 344 struct _FILE_ATTRIBUTE_TAG_INFORMATION
 345 {
 346     ULONG FileAttributes;
 347     ULONG ReparseTag;
 348 } FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION;
 349
 350 typedef enum _FSINFOCLASS {
 351     FileFsVolumeInformation = 1,
 352     FileFsLabelInformation,
 353     FileFsSizeInformation,
 354     FileFsDeviceInformation,
 355     FileFsAttributeInformation,
 356     FileFsControlInformation,
 357     FileFsFullSizeInformation,
 358     FileFsObjectIdInformation,
 359     FileFsMaximumInformation
 360 } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
 361
 362 typedef enum _KEY_INFORMATION_CLASS {
 363     KeyBasicInformation,
 364     KeyNodeInformation,
 365     KeyFullInformation
 366 } KEY_INFORMATION_CLASS;
 367
 368 typedef enum _KEY_VALUE_INFORMATION_CLASS {
 369     KeyValueBasicInformation,
 370     KeyValueFullInformation,
 371     KeyValuePartialInformation,
 372     KeyValueFullInformationAlign64,
 373     KeyValuePartialInformationAlign64
 374 } KEY_VALUE_INFORMATION_CLASS;
 375
 376 typedef enum _OBJECT_INFORMATION_CLASS {
 377     ObjectBasicInformation,
 378     ObjectNameInformation,
 379     ObjectTypeInformation,
 380     ObjectAllInformation,
 381     ObjectDataInformation
 382 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
 383
 384 typedef enum _PROCESSINFOCLASS {
 385     ProcessBasicInformation = 0,
 386     ProcessQuotaLimits = 1,
 387     ProcessIoCounters = 2,
 388     ProcessVmCounters = 3,
 389     ProcessTimes = 4,
 390     ProcessBasePriority = 5,
 391     ProcessRaisePriority = 6,
 392     ProcessDebugPort = 7,
 393     ProcessExceptionPort = 8,
 394     ProcessAccessToken = 9,
 395     ProcessLdtInformation = 10,
 396     ProcessLdtSize = 11,
 397     ProcessDefaultHardErrorMode = 12,
 398     ProcessIoPortHandlers = 13,
 399     ProcessPooledUsageAndLimits = 14,
 400     ProcessWorkingSetWatch = 15,
 401     ProcessUserModeIOPL = 16,
 402     ProcessEnableAlignmentFaultFixup = 17,
 403     ProcessPriorityClass = 18,
 404     ProcessWx86Information = 19,
 405     ProcessHandleCount = 20,
 406     ProcessAffinityMask = 21,
 407     ProcessPriorityBoost = 22,
 408     ProcessDeviceMap = 23,
 409     ProcessSessionInformation = 24,
 410     ProcessForegroundInformation = 25,
 411     ProcessWow64Information = 26,
 412     MaxProcessInfoClass
 413 } PROCESSINFOCLASS;
 414
 415 typedef enum _SECTION_INHERIT {
 416     ViewShare = 1,
 417     ViewUnmap = 2
 418 } SECTION_INHERIT;
 419
 420 typedef enum SYSTEM_INFORMATION_CLASS {
 421     SystemBasicInformation = 0,
 422     Unknown1,
 423     SystemPerformanceInformation = 2,
 424     SystemTimeOfDayInformation = 3, /* was SystemTimeInformation */
 425     Unknown4,
 426     SystemProcessInformation = 5,
 427     Unknown6,
 428     Unknown7,
 429     SystemProcessorPerformanceInformation = 8,
 430     Unknown9,
 431     Unknown10,
 432     SystemDriverInformation,
 433     Unknown12,
 434     Unknown13,
 435     Unknown14,
 436     Unknown15,
 437     SystemHandleList,
 438     Unknown17,
 439     Unknown18,
 440     Unknown19,
 441     Unknown20,
 442     SystemCacheInformation,
 443     Unknown22,
 444     SystemInterruptInformation = 23,
 445     SystemDpcBehaviourInformation = 24,
 446     SystemFullMemoryInformation = 25,
 447     SystemNotImplemented6 = 25,
 448     SystemLoadImage = 26,
 449     SystemUnloadImage = 27,
 450     SystemTimeAdjustmentInformation = 28,
 451     SystemTimeAdjustment = 28,
 452     SystemSummaryMemoryInformation = 29,
 453     SystemNotImplemented7 = 29,
 454     SystemNextEventIdInformation = 30,
 455     SystemNotImplemented8 = 30,
 456     SystemEventIdsInformation = 31,
 457     SystemCrashDumpInformation = 32,
 458     SystemExceptionInformation = 33,
 459     SystemCrashDumpStateInformation = 34,
 460     SystemKernelDebuggerInformation = 35,
 461     SystemContextSwitchInformation = 36,
 462     SystemRegistryQuotaInformation = 37,
 463     SystemCurrentTimeZoneInformation = 44,
 464     SystemTimeZoneInformation = 44,
 465     SystemLookasideInformation = 45,
 466     SystemSetTimeSlipEvent = 46,
 467     SystemCreateSession = 47,
 468     SystemDeleteSession = 48,
 469     SystemInvalidInfoClass4 = 49,
 470     SystemRangeStartInformation = 50,
 471     SystemVerifierInformation = 51,
 472     SystemAddVerifier = 52,
 473     SystemSessionProcessesInformation   = 53,
 474     SystemInformationClassMax
 475 } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
 476
 477 typedef enum _TIMER_TYPE {
 478     NotificationTimer,
 479     SynchronizationTimer
 480 } TIMER_TYPE;
 481
 482 typedef enum _THREADINFOCLASS {
 483     ThreadBasicInformation,
 484     ThreadTimes,
 485     ThreadPriority,
 486     ThreadBasePriority,
 487     ThreadAffinityMask,
 488     ThreadImpersonationToken,
 489     ThreadDescriptorTableEntry,
 490     ThreadEnableAlignmentFaultFixup,
 491     ThreadEventPair_Reusable,
 492     ThreadQuerySetWin32StartAddress,
 493     ThreadZeroTlsCell,
 494     ThreadPerformanceCount,
 495     ThreadAmILastThread,
 496     ThreadIdealProcessor,
 497     ThreadPriorityBoost,
 498     ThreadSetTlsArrayAddress,
 499     ThreadIsIoPending,
 500     MaxThreadInfoClass
 501 } THREADINFOCLASS;
 502
 503 typedef struct _THREAD_BASIC_INFORMATION
 504 {
 505     NTSTATUS  ExitStatus;
 506     PVOID     TebBaseAddress;
 507     CLIENT_ID ClientId;
 508     ULONG     AffinityMask;
 509     LONG      Priority;
 510     LONG      BasePriority;
 511 } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
 512
 513
 514 typedef enum _WINSTATIONINFOCLASS {
 515     WinStationInformation = 8
 516 } WINSTATIONINFOCLASS;
 517
 518 typedef enum
 519 {
 520     MemoryBasicInformation = 0
 521 } MEMORY_INFORMATION_CLASS;
 522
 523 /* return type of RtlDetermineDosPathNameType_U (FIXME: not the correct names) */
 524 typedef enum
 525 {
 526     INVALID_PATH = 0,
 527     UNC_PATH,              /* "//foo" */
 528     ABSOLUTE_DRIVE_PATH,   /* "c:/foo" */
 529     RELATIVE_DRIVE_PATH,   /* "c:foo" */
 530     ABSOLUTE_PATH,         /* "/foo" */
 531     RELATIVE_PATH,         /* "foo" */
 532     DEVICE_PATH,           /* "//./foo" */
 533     UNC_DOT_PATH           /* "//." */
 534 } DOS_PATHNAME_TYPE;
 535
 536 /***********************************************************************
 537  * IA64 specific types and data structures
 538  */
 539
 540 #ifdef __ia64__
 541
 542 typedef struct _FRAME_POINTERS {
 543   ULONGLONG MemoryStackFp;
 544   ULONGLONG BackingStoreFp;
 545 } FRAME_POINTERS, *PFRAME_POINTERS;
 546
 547 #define UNWIND_HISTORY_TABLE_SIZE 12
 548
 549 typedef struct _RUNTIME_FUNCTION {
 550   ULONG BeginAddress;
 551   ULONG EndAddress;
 552   ULONG UnwindInfoAddress;
 553 } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION;
 554
 555 typedef struct _UNWIND_HISTORY_TABLE_ENTRY {
 556   ULONG64 ImageBase;
 557   ULONG64 Gp;
 558   PRUNTIME_FUNCTION FunctionEntry;
 559 } UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY;
 560
 561 typedef struct _UNWIND_HISTORY_TABLE {
 562   ULONG Count;
 563   UCHAR Search;
 564   ULONG64 LowAddress;
 565   ULONG64 HighAddress;
 566   UNWIND_HISTORY_TABLE_ENTRY Entry[UNWIND_HISTORY_TABLE_SIZE];
 567 } UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE;
 568
 569 #endif /* defined(__ia64__) */
 570
 571 /***********************************************************************
 572  * Types and data structures
 573  */
 574
 575 /* This is used by NtQuerySystemInformation */
 576 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 577 typedef struct {
 578     FILETIME    ftKernelTime;
 579     FILETIME    ftUserTime;
 580     FILETIME    ftCreateTime;
 581     DWORD       dwTickCount;
 582     DWORD       dwStartAddress;
 583     DWORD       dwOwningPID;
 584     DWORD       dwThreadID;
 585     DWORD       dwCurrentPriority;
 586     DWORD       dwBasePriority;
 587     DWORD       dwContextSwitches;
 588     DWORD       dwThreadState;
 589     DWORD       dwWaitReason;
 590 } THREADINFO, *PTHREADINFO;
 591
 592 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 593 typedef struct _THREAD_INFO{
 594     DWORD Unknown1[6];
 595     DWORD ThreadID;
 596     DWORD Unknown2[3];
 597     DWORD Status;
 598     DWORD WaitReason;
 599     DWORD Unknown3[4];
 600 } THREAD_INFO, PTHREAD_INFO;
 601
 602 /***********************************************************************
 603  * Types and data structures
 604  */
 605
 606 typedef struct _IO_STATUS_BLOCK {
 607   union {
 608     NTSTATUS Status;
 609     PVOID Pointer;
 610   } DUMMYUNIONNAME;
 611
 612   ULONG_PTR Information;
 613 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
 614
 615 typedef void (WINAPI * PIO_APC_ROUTINE)(PVOID,PIO_STATUS_BLOCK,ULONG);
 616
 617 typedef struct _KEY_BASIC_INFORMATION {
 618     LARGE_INTEGER LastWriteTime;
 619     ULONG         TitleIndex;
 620     ULONG         NameLength;
 621     WCHAR         Name[1];
 622 } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
 623
 624 typedef struct _KEY_NODE_INFORMATION
 625 {
 626     LARGE_INTEGER LastWriteTime;
 627     ULONG         TitleIndex;
 628     ULONG         ClassOffset;
 629     ULONG         ClassLength;
 630     ULONG         NameLength;
 631     WCHAR         Name[1];
 632    /* Class[1]; */
 633 } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
 634
 635 typedef struct _KEY_FULL_INFORMATION
 636 {
 637     LARGE_INTEGER LastWriteTime;
 638     ULONG         TitleIndex;
 639     ULONG         ClassOffset;
 640     ULONG         ClassLength;
 641     ULONG         SubKeys;
 642     ULONG         MaxNameLen;
 643     ULONG         MaxClassLen;
 644     ULONG         Values;
 645     ULONG         MaxValueNameLen;
 646     ULONG         MaxValueDataLen;
 647     WCHAR         Class[1];
 648 } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
 649
 650 typedef struct _KEY_VALUE_ENTRY
 651 {
 652     PUNICODE_STRING ValueName;
 653     ULONG           DataLength;
 654     ULONG           DataOffset;
 655     ULONG           Type;
 656 } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
 657
 658 typedef struct _KEY_VALUE_BASIC_INFORMATION {
 659     ULONG TitleIndex;
 660     ULONG Type;
 661     ULONG NameLength;
 662     WCHAR Name[1];
 663 } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
 664
 665 typedef struct _KEY_VALUE_FULL_INFORMATION {
 666     ULONG TitleIndex;
 667     ULONG Type;
 668     ULONG DataOffset;
 669     ULONG DataLength;
 670     ULONG NameLength;
 671     WCHAR Name[1];
 672 } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
 673
 674 typedef struct _KEY_VALUE_PARTIAL_INFORMATION {
 675     ULONG TitleIndex;
 676     ULONG Type;
 677     ULONG DataLength;
 678     UCHAR Data[1];
 679 } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
 680
 681 typedef struct _OBJECT_ATTRIBUTES {
 682   ULONG Length;
 683   HANDLE RootDirectory;
 684   PUNICODE_STRING ObjectName;
 685   ULONG Attributes;
 686   PVOID SecurityDescriptor;       /* type SECURITY_DESCRIPTOR */
 687   PVOID SecurityQualityOfService; /* type SECURITY_QUALITY_OF_SERVICE */
 688 } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
 689
 690 typedef struct _OBJECT_DATA_INFORMATION {
 691     BOOLEAN InheritHandle;
 692     BOOLEAN ProtectFromClose;
 693 } OBJECT_DATA_INFORMATION, *POBJECT_DATA_INFORMATION;
 694
 695 typedef struct _PROCESS_BASIC_INFORMATION {
 696 #ifdef __WINESRC__
 697     DWORD ExitStatus;
 698     DWORD PebBaseAddress;
 699     DWORD AffinityMask;
 700     DWORD BasePriority;
 701     ULONG UniqueProcessId;
 702     ULONG InheritedFromUniqueProcessId;
 703 #else
 704     PVOID Reserved1;
 705     PPEB PebBaseAddress;
 706     PVOID Reserved2[2];
 707     ULONG_PTR UniqueProcessId;
 708     PVOID Reserved3;
 709 #endif
 710 } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
 711
 712 typedef struct _PROCESS_INFO {
 713     DWORD    Offset;             /* 00 offset to next PROCESS_INFO ok*/
 714     DWORD    ThreadCount;        /* 04 number of ThreadInfo member ok */
 715     DWORD    Unknown1[6];
 716     FILETIME CreationTime;       /* 20 */
 717     DWORD    Unknown2[5];
 718     PWCHAR   ProcessName;        /* 3c ok */
 719     DWORD    BasePriority;
 720     DWORD    ProcessID;          /* 44 ok*/
 721     DWORD    ParentProcessID;
 722     DWORD    HandleCount;
 723     DWORD    Unknown3[2];        /* 50 */
 724     ULONG    PeakVirtualSize;
 725     ULONG    VirtualSize;
 726     ULONG    PageFaultCount;
 727     ULONG    PeakWorkingSetSize;
 728     ULONG    WorkingSetSize;
 729     ULONG    QuotaPeakPagedPoolUsage;
 730     ULONG    QuotaPagedPoolUsage;
 731     ULONG    QuotaPeakNonPagedPoolUsage;
 732     ULONG    QuotaNonPagedPoolUsage;
 733     ULONG    PagefileUsage;
 734     ULONG    PeakPagefileUsage;
 735     DWORD    PrivateBytes;
 736     DWORD    Unknown6[4];
 737     THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/
 738 } PROCESS_INFO, PPROCESS_INFO;
 739
 740 typedef struct _RTL_HEAP_DEFINITION {
 741     ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
 742
 743     ULONG Unknown[11];
 744 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 745
 746 typedef struct _RTL_RWLOCK {
 747     RTL_CRITICAL_SECTION rtlCS;
 748
 749     HANDLE hSharedReleaseSemaphore;
 750     UINT   uSharedWaiters;
 751
 752     HANDLE hExclusiveReleaseSemaphore;
 753     UINT   uExclusiveWaiters;
 754
 755     INT    iNumberActive;
 756     HANDLE hOwningThreadId;
 757     DWORD  dwTimeoutBoost;
 758     PVOID  pDebugInfo;
 759 } RTL_RWLOCK, *LPRTL_RWLOCK;
 760
 761 /* System Information Class 0x00 */
 762 typedef struct _SYSTEM_BASIC_INFORMATION {
 763 #ifdef __WINESRC__
 764     DWORD dwUnknown1;
 765     ULONG uKeMaximumIncrement;
 766     ULONG uPageSize;
 767     ULONG uMmNumberOfPhysicalPages;
 768     ULONG uMmLowestPhysicalPage;
 769     ULONG uMmHighestPhysicalPage;
 770     ULONG uAllocationGranularity;
 771     PVOID pLowestUserAddress;
 772     PVOID pMmHighestUserAddress;
 773     ULONG uKeActiveProcessors;
 774     BYTE bKeNumberProcessors;
 775     BYTE bUnknown2;
 776     WORD wUnknown3;
 777 #else
 778     BYTE Reserved1[24];
 779     PVOID Reserved2[4];
 780     CCHAR NumberOfProcessors;
 781 #endif
 782 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 783
 784 /* System Information Class 0x15 */
 785 typedef struct {
 786     ULONG CurrentSize;
 787     ULONG PeakSize;
 788     ULONG PageFaultCount;
 789     ULONG MinimumWorkingSet;
 790     ULONG MaximumWorkingSet;
 791     ULONG unused[4];
 792 } SYSTEM_CACHE_INFORMATION;
 793
 794 typedef struct _SYSTEM_CONFIGURATION_INFO {
 795     union {
 796         ULONG   OemId;
 797         struct {
 798             WORD ProcessorArchitecture;
 799             WORD Reserved;
 800         } tag1;
 801     } tag2;
 802     ULONG PageSize;
 803     PVOID MinimumApplicationAddress;
 804     PVOID MaximumApplicationAddress;
 805     ULONG ActiveProcessorMask;
 806     ULONG NumberOfProcessors;
 807     ULONG ProcessorType;
 808     ULONG AllocationGranularity;
 809     WORD  ProcessorLevel;
 810     WORD  ProcessorRevision;
 811 } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
 812
 813 /* System Information Class 0x0b */
 814 typedef struct {
 815     PVOID pvAddress;
 816     DWORD dwUnknown1;
 817     DWORD dwUnknown2;
 818     DWORD dwEntryIndex;
 819     DWORD dwUnknown3;
 820     char szName[MAX_PATH + 1];
 821 } SYSTEM_DRIVER_INFORMATION;
 822
 823 typedef struct _SYSTEM_EXCEPTION_INFORMATION {
 824     BYTE Reserved1[16];
 825 } SYSTEM_EXCEPTION_INFORMATION, *PSYSTEM_EXCEPTION_INFORMATION;
 826
 827 typedef struct _SYSTEM_LOOKASIDE_INFORMATION {
 828     BYTE Reserved1[32];
 829 } SYSTEM_LOOKASIDE_INFORMATION, *PSYSTEM_LOOKASIDE_INFORMATION;
 830
 831 typedef struct _SYSTEM_INTERRUPT_INFORMATION {
 832     BYTE Reserved1[24];
 833 } SYSTEM_INTERRUPT_INFORMATION, *PSYSTEM_INTERRUPT_INFORMATION;
 834
 835 typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION {
 836         BOOLEAN  DebuggerEnabled;
 837         BOOLEAN  DebuggerNotPresent;
 838 } SYSTEM_KERNEL_DEBUGGER_INFORMATION, *PSYSTEM_KERNEL_DEBUGGER_INFORMATION;
 839
 840 /* System Information Class 0x10 */
 841 typedef struct {
 842     USHORT dwPID;
 843     USHORT dwCreatorBackTraceIndex;
 844     BYTE bObjectType;
 845     BYTE bHandleAttributes;
 846     USHORT usHandleOffset;
 847     DWORD dwKeObject;
 848     ULONG ulGrantedAccess;
 849 } HANDLEINFO, *PHANDLEINFO; /* FIXME: SYSTEM_HANDLE_INFORMATION? */
 850
 851 typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
 852     BYTE Reserved1[312];
 853 } SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
 854
 855 /* System Information Class 0x02 */
 856 typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
 857 #ifdef __WINESRC__
 858     LARGE_INTEGER liIdleTime;
 859     DWORD dwSpare[10];
 860 #else
 861     LARGE_INTEGER IdleTime;
 862     LARGE_INTEGER KernelTime;
 863     LARGE_INTEGER UserTime;
 864     LARGE_INTEGER Reserved1[2];
 865     ULONG Reserved2;
 866 #endif
 867 } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
 868
 869 /* System Information Class 0x05 */
 870 typedef struct _SYSTEM_PROCESS_INFORMATION {
 871 #ifdef __WINESRC__
 872     DWORD dwOffset;
 873     DWORD dwThreadCount;
 874     DWORD dwUnknown1[6];
 875     FILETIME ftCreationTime;
 876     DWORD dwUnknown2[5];
 877     WCHAR *pszProcessName;
 878     DWORD dwBasePriority;
 879     DWORD dwProcessID;
 880     DWORD dwParentProcessID;
 881     DWORD dwHandleCount;
 882     DWORD dwUnknown3;
 883     DWORD dwUnknown4;
 884     DWORD dwVirtualBytesPeak;
 885     DWORD dwVirtualBytes;
 886     DWORD dwPageFaults;
 887     DWORD dwWorkingSetPeak;
 888     DWORD dwWorkingSet;
 889     DWORD dwUnknown5;
 890     DWORD dwPagedPool;
 891     DWORD dwUnknown6;
 892     DWORD dwNonPagedPool;
 893     DWORD dwPageFileBytesPeak;
 894     DWORD dwPrivateBytes;
 895     DWORD dwPageFileBytes;
 896     DWORD dwUnknown7[4];
 897     THREADINFO ti[1];
 898 #else
 899     ULONG NextEntryOffset;
 900     BYTE Reserved1[52];
 901     PVOID Reserved2[3];
 902     HANDLE UniqueProcessId;
 903     PVOID Reserved3;
 904     ULONG HandleCount;
 905     BYTE Reserved4[4];
 906     PVOID Reserved5[11];
 907     SIZE_T PeakPagefileUsage;
 908     SIZE_T PrivatePageCount;
 909     LARGE_INTEGER Reserved6[6];
 910 #endif
 911 } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
 912
 913 typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {
 914     ULONG RegistryQuotaAllowed;
 915     ULONG RegistryQuotaUsed;
 916     PVOID Reserved1;
 917 } SYSTEM_REGISTRY_QUOTA_INFORMATION, *PSYSTEM_REGISTRY_QUOTA_INFORMATION;
 918
 919 typedef struct _SYSTEM_TIME_ADJUSTMENT {
 920     ULONG   TimeAdjustment;
 921     BOOLEAN TimeAdjustmentDisabled;
 922 } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
 923
 924 /* System Information Class 0x03 */
 925 typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {
 926 #ifdef __WINESRC__
 927     LARGE_INTEGER liKeBootTime;
 928     LARGE_INTEGER liKeSystemTime;
 929     LARGE_INTEGER liExpTimeZoneBias;
 930     ULONG uCurrentTimeZoneId;
 931     DWORD dwReserved;
 932 #else
 933     BYTE Reserved1[48];
 934 #endif
 935 } SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; /* was SYSTEM_TIME_INFORMATION */
 936
 937 typedef struct _TIME_FIELDS
 938 {   CSHORT Year;
 939     CSHORT Month;
 940     CSHORT Day;
 941     CSHORT Hour;
 942     CSHORT Minute;
 943     CSHORT Second;
 944     CSHORT Milliseconds;
 945     CSHORT Weekday;
 946 } TIME_FIELDS, *PTIME_FIELDS;
 947
 948 typedef struct _WINSTATIONINFORMATIONW {
 949   BYTE Reserved2[70];
 950   ULONG LogonId;
 951   BYTE Reserved3[1140];
 952 } WINSTATIONINFORMATIONW, *PWINSTATIONINFORMATIONW;
 953
 954 typedef struct _VM_COUNTERS_ {
 955     ULONG PeakVirtualSize;
 956     ULONG VirtualSize;
 957     ULONG PageFaultCount;
 958     ULONG PeakWorkingSetSize;
 959     ULONG WorkingSetSize;
 960     ULONG QuotaPeakPagedPoolUsage;
 961     ULONG QuotaPagedPoolUsage;
 962     ULONG QuotaPeakNonPagedPoolUsage;
 963     ULONG QuotaNonPagedPoolUsage;
 964     ULONG PagefileUsage;
 965     ULONG PeakPagefileUsage;
 966 } VM_COUNTERS, *PVM_COUNTERS;
 967
 968 typedef BOOLEAN (WINAPI * PWINSTATIONQUERYINFORMATIONW)(HANDLE,ULONG,WINSTATIONINFOCLASS,PVOID,ULONG,PULONG);
 969
 970 typedef struct _LDR_RESOURCE_INFO
 971 {
 972     ULONG Type;
 973     ULONG Name;
 974     ULONG Language;
 975 } LDR_RESOURCE_INFO, *PLDR_RESOURCE_INFO;
 976
 977
 978 /* debug buffer definitions */
 979
 980 typedef struct _DEBUG_BUFFER {
 981   HANDLE SectionHandle;
 982   PVOID  SectionBase;
 983   PVOID  RemoteSectionBase;
 984   ULONG  SectionBaseDelta;
 985   HANDLE EventPairHandle;
 986   ULONG  Unknown[2];
 987   HANDLE RemoteThreadHandle;
 988   ULONG  InfoClassMask;
 989   ULONG  SizeOfInfo;
 990   ULONG  AllocatedSize;
 991   ULONG  SectionSize;
 992   PVOID  ModuleInformation;
 993   PVOID  BackTraceInformation;
 994   PVOID  HeapInformation;
 995   PVOID  LockInformation;
 996   PVOID  Reserved[8];
 997 } DEBUG_BUFFER, *PDEBUG_BUFFER;
 998
 999 #define PDI_MODULES                       0x01
1000 #define PDI_BACKTRACE                     0x02
1001 #define PDI_HEAPS                         0x04
1002 #define PDI_HEAP_TAGS                     0x08
1003 #define PDI_HEAP_BLOCKS                   0x10
1004 #define PDI_LOCKS                         0x20
1005
1006 typedef struct _DEBUG_MODULE_INFORMATION {
1007   ULONG  Reserved[2];
1008   ULONG  Base;
1009   ULONG  Size;
1010   ULONG  Flags;
1011   USHORT Index;
1012   USHORT Unknown;
1013   USHORT LoadCount;
1014   USHORT ModuleNameOffset;
1015   CHAR   ImageName[256];
1016 } DEBUG_MODULE_INFORMATION, *PDEBUG_MODULE_INFORMATION;
1017
1018 typedef struct _DEBUG_HEAP_INFORMATION {
1019   ULONG  Base;
1020   ULONG  Flags;
1021   USHORT Granularity;
1022   USHORT Unknown;
1023   ULONG  Allocated;
1024   ULONG  Committed;
1025   ULONG  TagCount;
1026   ULONG  BlockCount;
1027   ULONG  Reserved[7];
1028   PVOID  Tags;
1029   PVOID  Blocks;
1030 } DEBUG_HEAP_INFORMATION, *PDEBUG_HEAP_INFORMATION;
1031
1032 typedef struct _DEBUG_LOCK_INFORMATION {
1033   PVOID  Address;
1034   USHORT Type;
1035   USHORT CreatorBackTraceIndex;
1036   ULONG  OwnerThreadId;
1037   ULONG  ActiveCount;
1038   ULONG  ContentionCount;
1039   ULONG  EntryCount;
1040   ULONG  RecursionCount;
1041   ULONG  NumberOfSharedWaiters;
1042   ULONG  NumberOfExclusiveWaiters;
1043 } DEBUG_LOCK_INFORMATION, *PDEBUG_LOCK_INFORMATION;
1044
1045 typedef struct _PORT_MESSAGE_HEADER {
1046   USHORT DataSize;
1047   USHORT MessageSize;
1048   USHORT MessageType;
1049   USHORT VirtualRangesOffset;
1050   CLIENT_ID ClientId;
1051   ULONG MessageId;
1052   ULONG SectionSize;
1053 } PORT_MESSAGE_HEADER, *PPORT_MESSAGE_HEADER, PORT_MESSAGE, *PPORT_MESSAGE;
1054
1055 /***********************************************************************
1056  * Defines
1057  */
1058
1059 /* flags for NtCreateFile and NtOpenFile */
1060 #define FILE_DIRECTORY_FILE             0x00000001
1061 #define FILE_WRITE_THROUGH              0x00000002
1062 #define FILE_SEQUENTIAL_ONLY            0x00000004
1063 #define FILE_NO_INTERMEDIATE_BUFFERING  0x00000008
1064 #define FILE_SYNCHRONOUS_IO_ALERT       0x00000010
1065 #define FILE_SYNCHRONOUS_IO_NONALERT    0x00000020
1066 #define FILE_NON_DIRECTORY_FILE         0x00000040
1067 #define FILE_CREATE_TREE_CONNECTION     0x00000080
1068 #define FILE_COMPLETE_IF_OPLOCKED       0x00000100
1069 #define FILE_NO_EA_KNOWLEDGE            0x00000200
1070 #define FILE_OPEN_FOR_RECOVERY          0x00000400
1071 #define FILE_RANDOM_ACCESS              0x00000800
1072 #define FILE_DELETE_ON_CLOSE            0x00001000
1073 #define FILE_OPEN_BY_FILE_ID            0x00002000
1074 #define FILE_OPEN_FOR_BACKUP_INTENT     0x00004000
1075 #define FILE_NO_COMPRESSION             0x00008000
1076 #define FILE_RESERVE_OPFILTER           0x00100000
1077 #define FILE_TRANSACTED_MODE            0x00200000
1078 #define FILE_OPEN_OFFLINE_FILE          0x00400000
1079
1080 #define FILE_ATTRIBUTE_VALID_FLAGS      0x00007fb7
1081 #define FILE_ATTRIBUTE_VALID_SET_FLAGS  0x000031a7
1082
1083 /* status for NtCreateFile or NtOpenFile */
1084 #define FILE_SUPERSEDED                 0
1085 #define FILE_OPENED                     1
1086 #define FILE_CREATED                    2
1087 #define FILE_OVERWRITTEN                3
1088 #define FILE_EXISTS                     4
1089 #define FILE_DOES_NOT_EXIST             5
1090
1091 /* disposition for NtCreateFile */
1092 #define FILE_SUPERSEDE                  0
1093 #define FILE_OPEN                       1
1094 #define FILE_CREATE                     2
1095 #define FILE_OPEN_IF                    3
1096 #define FILE_OVERWRITE                  4
1097 #define FILE_OVERWRITE_IF               5
1098 #define FILE_MAXIMUM_DISPOSITION        5
1099
1100 /* Characteristics of a File System */
1101 #define FILE_REMOVABLE_MEDIA            0x00000001
1102 #define FILE_READ_ONLY_DEVICE           0x00000002
1103 #define FILE_FLOPPY_DISKETTE            0x00000004
1104 #define FILE_WRITE_ONE_MEDIA            0x00000008
1105 #define FILE_REMOTE_DEVICE              0x00000010
1106 #define FILE_DEVICE_IS_MOUNTED          0x00000020
1107 #define FILE_VIRTUAL_VOLUME             0x00000040
1108
1109 #if (_WIN32_WINNT >= 0x0501)
1110 #define INTERNAL_TS_ACTIVE_CONSOLE_ID ( *((volatile ULONG*)(0x7ffe02d8)) )
1111 #endif /* (_WIN32_WINNT >= 0x0501) */
1112
1113 #define LOGONID_CURRENT    ((ULONG)-1)
1114
1115 #define OBJ_INHERIT          0x00000002L
1116 #define OBJ_PERMANENT        0x00000010L
1117 #define OBJ_EXCLUSIVE        0x00000020L
1118 #define OBJ_CASE_INSENSITIVE 0x00000040L
1119 #define OBJ_OPENIF           0x00000080L
1120 #define OBJ_OPENLINK         0x00000100L
1121 #define OBJ_KERNEL_HANDLE    0x00000200L
1122 #define OBJ_VALID_ATTRIBUTES 0x000003F2L
1123
1124 #define SERVERNAME_CURRENT ((HANDLE)NULL)
1125
1126 typedef void (CALLBACK *PNTAPCFUNC)(ULONG_PTR,ULONG_PTR,ULONG_PTR); /* FIXME: not the right name */
1127 typedef void (CALLBACK *PRTL_THREAD_START_ROUTINE)(LPVOID); /* FIXME: not the right name */
1128
1129
1130 /* DbgPrintEx default levels */
1131 #define DPFLTR_ERROR_LEVEL     0
1132 #define DPFLTR_WARNING_LEVEL   1
1133 #define DPFLTR_TRACE_LEVEL     2
1134 #define DPFLTR_INFO_LEVEL      3
1135 #define DPFLTR_MASK    0x8000000
1136
1137 /***********************************************************************
1138  * Function declarations
1139  */
1140
1141 extern LPSTR _strlwr(LPSTR str); /* FIXME: Doesn't belong here */
1142 extern LPSTR _strupr(LPSTR str); /* FIXME: Doesn't belong here */
1143
1144 #if defined(__i386__) && defined(__GNUC__)
1145 static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
1146 static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
1147 #else  /* __i386__ && __GNUC__ */
1148 void WINAPI DbgBreakPoint(void);
1149 void WINAPI DbgUserBreakPoint(void);
1150 #endif  /* __i386__ && __GNUC__ */
1151 NTSTATUS WINAPIV DbgPrint(LPCSTR fmt, ...);
1152 NTSTATUS WINAPIV DbgPrintEx(ULONG iComponentId, ULONG Level, LPCSTR fmt, ...);
1153
1154 NTSTATUS  WINAPI LdrAccessResource(HMODULE,const IMAGE_RESOURCE_DATA_ENTRY*,void**,PULONG);
1155 NTSTATUS  WINAPI LdrFindResourceDirectory_U(HMODULE,const LDR_RESOURCE_INFO*,ULONG,const IMAGE_RESOURCE_DIRECTORY**);
1156 NTSTATUS  WINAPI LdrFindResource_U(HMODULE,const LDR_RESOURCE_INFO*,ULONG,const IMAGE_RESOURCE_DATA_ENTRY**);
1157 NTSTATUS  WINAPI LdrGetDllHandle(ULONG, ULONG, const UNICODE_STRING*, HMODULE*);
1158 NTSTATUS  WINAPI LdrGetProcedureAddress(HMODULE, const ANSI_STRING*, ULONG, void**);
1159 void      WINAPI LdrInitializeThunk(HANDLE,ULONG,ULONG,ULONG);
1160 NTSTATUS  WINAPI LdrLoadDll(LPCWSTR, DWORD, const UNICODE_STRING*, HMODULE*);
1161 void      WINAPI LdrShutdownProcess(void);
1162 void      WINAPI LdrShutdownThread(void);
1163 NTSTATUS  WINAPI NtAccessCheck(PSECURITY_DESCRIPTOR,HANDLE,ACCESS_MASK,PGENERIC_MAPPING,PPRIVILEGE_SET,PULONG,PULONG,PBOOLEAN);
1164 NTSTATUS  WINAPI NtAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
1165 NTSTATUS  WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,PVOID,ULONG*,ULONG,ULONG);
1166 NTSTATUS  WINAPI NtCancelTimer(HANDLE, BOOLEAN*);
1167 NTSTATUS  WINAPI NtClearEvent(HANDLE);
1168 NTSTATUS  WINAPI NtClose(HANDLE);
1169 NTSTATUS  WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1170 NTSTATUS  WINAPI NtCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
1171 NTSTATUS  WINAPI NtCreateKey(PHKEY,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
1172 NTSTATUS  WINAPI NtCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
1173 NTSTATUS  WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
1174 NTSTATUS  WINAPI NtCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
1175 NTSTATUS  WINAPI NtDelayExecution(BOOLEAN,const LARGE_INTEGER*);
1176 NTSTATUS  WINAPI NtDeleteKey(HKEY);
1177 NTSTATUS  WINAPI NtDeleteValueKey(HKEY,const UNICODE_STRING *);
1178 NTSTATUS  WINAPI NtDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1179 NTSTATUS  WINAPI NtDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
1180 NTSTATUS  WINAPI NtEnumerateKey(HKEY,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1181 NTSTATUS  WINAPI NtEnumerateValueKey(HKEY,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1182 NTSTATUS  WINAPI NtFlushBuffersFile(HANDLE,IO_STATUS_BLOCK*);
1183 NTSTATUS  WINAPI NtFlushKey(HKEY);
1184 NTSTATUS  WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,ULONG*,ULONG);
1185 NTSTATUS  WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
1186 NTSTATUS  WINAPI NtGetContextThread(HANDLE,CONTEXT*);
1187 NTSTATUS  WINAPI NtImpersonateAnonymousToken(HANDLE);
1188 NTSTATUS  WINAPI NtImpersonateClientOfPort(HANDLE,PPORT_MESSAGE);
1189 NTSTATUS  WINAPI NtImpersonateThread(HANDLE,HANDLE,PSECURITY_QUALITY_OF_SERVICE);
1190 NTSTATUS  WINAPI NtLoadKey(const OBJECT_ATTRIBUTES *,const OBJECT_ATTRIBUTES *);
1191 NTSTATUS  WINAPI NtLockFile(HANDLE,HANDLE,PIO_APC_ROUTINE,void*,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,ULONG*,BOOLEAN,BOOLEAN);
1192 NTSTATUS  WINAPI NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
1193 NTSTATUS  WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
1194 NTSTATUS  WINAPI NtNotifyChangeKey(HKEY,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
1195 NTSTATUS  WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1196 NTSTATUS  WINAPI NtOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
1197 NTSTATUS  WINAPI NtOpenKey(PHKEY,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1198 NTSTATUS  WINAPI NtOpenProcessToken(HANDLE,DWORD,HANDLE *);
1199 NTSTATUS  WINAPI NtOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
1200 NTSTATUS  WINAPI NtOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1201 NTSTATUS  WINAPI NtOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
1202 NTSTATUS  WINAPI NtOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
1203 NTSTATUS  WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
1204 NTSTATUS  WINAPI NtPulseEvent(HANDLE,PULONG);
1205 NTSTATUS  WINAPI NtQueueApcThread(HANDLE,PNTAPCFUNC,ULONG_PTR,ULONG_PTR,ULONG_PTR);
1206 NTSTATUS  WINAPI NtQueryAttributesFile(const OBJECT_ATTRIBUTES*,FILE_BASIC_INFORMATION*);
1207 NTSTATUS  WINAPI NtQueryDefaultLocale(BOOLEAN,LCID*);
1208 NTSTATUS  WINAPI NtQueryDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
1209 NTSTATUS  WINAPI NtQueryFullAttributesFile(const OBJECT_ATTRIBUTES*,FILE_NETWORK_OPEN_INFORMATION*);
1210 NTSTATUS  WINAPI NtQueryInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS);
1211 NTSTATUS  WINAPI NtQueryInformationProcess(HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);
1212 NTSTATUS  WINAPI NtQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
1213 NTSTATUS  WINAPI NtQueryInformationToken(HANDLE,DWORD,LPVOID,DWORD,LPDWORD);
1214 NTSTATUS  WINAPI NtQueryKey(HKEY,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1215 NTSTATUS  WINAPI NtQueryMultipleValueKey(HKEY,PVALENTW,ULONG,PVOID,ULONG,PULONG);
1216 NTSTATUS  WINAPI NtQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
1217 NTSTATUS  WINAPI NtQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
1218 NTSTATUS  WINAPI NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1219 NTSTATUS  WINAPI NtQuerySystemTime(PLARGE_INTEGER);
1220 NTSTATUS  WINAPI NtQueryValueKey(HKEY,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
1221 NTSTATUS  WINAPI NtQueryVirtualMemory(HANDLE,LPCVOID,MEMORY_INFORMATION_CLASS,PVOID,ULONG,ULONG*);
1222 NTSTATUS  WINAPI NtQueryVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1223 void      WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
1224 NTSTATUS  WINAPI NtReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
1225 NTSTATUS  WINAPI NtReadVirtualMemory(HANDLE,const void*,void*,SIZE_T,SIZE_T*);
1226 NTSTATUS  WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
1227 NTSTATUS  WINAPI NtReplaceKey(POBJECT_ATTRIBUTES,HKEY,POBJECT_ATTRIBUTES);
1228 NTSTATUS  WINAPI NtResetEvent(HANDLE,PULONG);
1229 NTSTATUS  WINAPI NtRestoreKey(HKEY,HANDLE,ULONG);
1230 NTSTATUS  WINAPI NtResumeThread(HANDLE,PULONG);
1231 NTSTATUS  WINAPI NtSaveKey(HKEY,HANDLE);
1232 NTSTATUS  WINAPI NtSetContextThread(HANDLE,const CONTEXT*);
1233 NTSTATUS  WINAPI NtSetDefaultLocale(BOOLEAN,LCID);
1234 NTSTATUS  WINAPI NtSetEvent(HANDLE,PULONG);
1235 NTSTATUS  WINAPI NtSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);
1236 NTSTATUS  WINAPI NtSetInformationKey(HKEY,const int,PVOID,ULONG);
1237 NTSTATUS  WINAPI NtSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
1238 NTSTATUS  WINAPI NtSetInformationThread(HANDLE,THREADINFOCLASS,LPCVOID,ULONG);
1239 NTSTATUS  WINAPI NtSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
1240 NTSTATUS  WINAPI NtSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
1241 NTSTATUS  WINAPI NtSetTimer(HANDLE, const LARGE_INTEGER*, PTIMERAPCROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
1242 NTSTATUS  WINAPI NtSetValueKey(HKEY,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
1243 NTSTATUS  WINAPI NtSuspendThread(HANDLE,PULONG);
1244 NTSTATUS  WINAPI NtTerminateProcess(HANDLE,LONG);
1245 NTSTATUS  WINAPI NtTerminateThread(HANDLE,LONG);
1246 NTSTATUS  WINAPI NtUnloadKey(HKEY);
1247 NTSTATUS  WINAPI NtUnlockFile(HANDLE,PIO_STATUS_BLOCK,PLARGE_INTEGER,PLARGE_INTEGER,PULONG);
1248 NTSTATUS  WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
1249 NTSTATUS  WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
1250 NTSTATUS  WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
1251 NTSTATUS  WINAPI NtWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
1252 NTSTATUS  WINAPI NtWriteFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,const void*,ULONG,PLARGE_INTEGER,PULONG);
1253 NTSTATUS  WINAPI NtWriteVirtualMemory(HANDLE,void*,const void*,SIZE_T,SIZE_T*);
1254
1255 void      WINAPI RtlAcquirePebLock(void);
1256 BYTE      WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK,BYTE);
1257 BYTE      WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK,BYTE);
1258 NTSTATUS  WINAPI RtlAddAce(PACL,DWORD,DWORD,PACE_HEADER,DWORD);
1259 NTSTATUS  WINAPI RtlAddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
1260 NTSTATUS  WINAPI RtlAddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
1261 NTSTATUS  WINAPI RtlAddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
1262 NTSTATUS  WINAPI RtlAddAccessDeniedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
1263 PVOID     WINAPI RtlAddVectoredExceptionHandler(ULONG,PVECTORED_EXCEPTION_HANDLER);
1264 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
1265 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
1266 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
1267 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
1268 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
1269 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
1270 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
1271 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
1272 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
1273 BOOLEAN   WINAPI RtlAreAllAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1274 BOOLEAN   WINAPI RtlAreAnyAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1275 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
1276 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
1277
1278 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
1279 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
1280 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
1281 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
1282 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
1283 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1284 DWORD     WINAPI RtlComputeCrc32(DWORD,PBYTE,INT);
1285 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
1286 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
1287 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
1288 void      WINAPI RtlCopyLuid(PLUID,const LUID*);
1289 void      WINAPI RtlCopyLuidAndAttributesArray(ULONG,const LUID_AND_ATTRIBUTES*,PLUID_AND_ATTRIBUTES);
1290 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
1291 void      WINAPI RtlCopyString(STRING*,const STRING*);
1292 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
1293 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
1294 NTSTATUS  WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
1295 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
1296 NTSTATUS  WINAPI RtlCreateProcessParameters(RTL_USER_PROCESS_PARAMETERS**,const UNICODE_STRING*,
1297                                             const UNICODE_STRING*,const UNICODE_STRING*,
1298                                             const UNICODE_STRING*,PWSTR,const UNICODE_STRING*,
1299                                             const UNICODE_STRING*,const UNICODE_STRING*,
1300                                             const UNICODE_STRING*);
1301 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
1302 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
1303 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
1304 NTSTATUS  WINAPI RtlCreateUserThread(HANDLE,const SECURITY_DESCRIPTOR*,BOOLEAN,PVOID,SIZE_T,SIZE_T,PRTL_THREAD_START_ROUTINE,void*,HANDLE*,CLIENT_ID*);
1305
1306 NTSTATUS  WINAPI RtlDeleteAce(PACL,DWORD);
1307 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
1308 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
1309 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
1310 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams(RTL_USER_PROCESS_PARAMETERS*);
1311 NTSTATUS  WINAPI RtlDestroyEnvironment(PWSTR);
1312 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
1313 void      WINAPI RtlDestroyProcessParameters(RTL_USER_PROCESS_PARAMETERS*);
1314 DOS_PATHNAME_TYPE WINAPI RtlDetermineDosPathNameType_U(PCWSTR);
1315 BOOLEAN   WINAPI RtlDoesFileExists_U(LPCWSTR);
1316 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(PCWSTR,PUNICODE_STRING,PWSTR*,CURDIR*);
1317 ULONG     WINAPI RtlDosSearchPath_U(LPCWSTR, LPCWSTR, LPCWSTR, ULONG, LPWSTR, LPWSTR*);
1318 WCHAR     WINAPI RtlDowncaseUnicodeChar(WCHAR);
1319 NTSTATUS  WINAPI RtlDowncaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1320 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
1321 NTSTATUS  WINAPI RtlDuplicateUnicodeString(int,const UNICODE_STRING*,UNICODE_STRING*);
1322
1323 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
1324 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
1325 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
1326 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
1327 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
1328 NTSTATUS  WINAPI RtlEqualComputerName(const UNICODE_STRING*,const UNICODE_STRING*);
1329 NTSTATUS  WINAPI RtlEqualDomainName(const UNICODE_STRING*,const UNICODE_STRING*);
1330 BOOLEAN   WINAPI RtlEqualLuid(const LUID*,const LUID*);
1331 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
1332 BOOL      WINAPI RtlEqualSid(PSID,PSID);
1333 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
1334 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1335 NTSTATUS  WINAPI RtlExpandEnvironmentStrings_U(PWSTR, const UNICODE_STRING*, UNICODE_STRING*, ULONG*);
1336 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
1337 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
1338 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
1339
1340 NTSTATUS  WINAPI RtlFindCharInUnicodeString(int,const UNICODE_STRING*,const UNICODE_STRING*,USHORT*);
1341 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
1342 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
1343 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1344 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1345 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1346 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
1347 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
1348 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
1349 NTSTATUS  WINAPI RtlFindMessage(HMODULE,ULONG,ULONG,ULONG,const MESSAGE_RESOURCE_ENTRY**);
1350 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
1351 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1352 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1353 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
1354 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
1355 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1356 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
1357 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
1358 NTSTATUS  WINAPI RtlFormatMessage(LPWSTR,UCHAR,BOOLEAN,BOOLEAN,BOOLEAN,va_list *,LPWSTR,ULONG);
1359 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
1360 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
1361 void      WINAPI RtlFreeOemString(POEM_STRING);
1362 DWORD     WINAPI RtlFreeSid(PSID);
1363 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
1364
1365 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
1366 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
1367 NTSTATUS  WINAPI RtlGetCurrentDirectory_U(ULONG, LPWSTR);
1368 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1369 ULONG     WINAPI RtlGetFullPathName_U(PCWSTR,ULONG,PWSTR,PWSTR*);
1370 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1371 DWORD     WINAPI RtlGetLastWin32Error(void);
1372 DWORD     WINAPI RtlGetLongestNtPathLength(void);
1373 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
1374 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1375 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
1376 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1377 NTSTATUS  WINAPI RtlGetVersion(RTL_OSVERSIONINFOEXW*);
1378
1379 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
1380 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
1381 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
1382 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
1383 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
1384 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
1385 void      WINAPI RtlInitString(PSTRING,PCSZ);
1386 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
1387 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
1388 NTSTATUS  WINAPI RtlInitUnicodeStringEx(PUNICODE_STRING,PCWSTR);
1389 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
1390 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
1391 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1392 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
1393 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
1394
1395 NTSTATUS  WINAPI RtlInt64ToUnicodeString(ULONGLONG,ULONG,UNICODE_STRING *);
1396 NTSTATUS  WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
1397 NTSTATUS  WINAPI RtlIntegerToUnicodeString(ULONG,ULONG,UNICODE_STRING *);
1398 ULONG     WINAPI RtlIsDosDeviceName_U(PCWSTR);
1399 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
1400 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
1401
1402 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
1403 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
1404 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
1405 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
1406 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
1407 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
1408 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
1409 NTSTATUS  WINAPI RtlLargeIntegerToChar(const ULONGLONG *,ULONG,ULONG,PCHAR);
1410 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
1411 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
1412 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
1413 DWORD     WINAPI RtlLengthSid(PSID);
1414 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1415 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
1416
1417 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
1418 void      WINAPI RtlMapGenericMask(PACCESS_MASK,const GENERIC_MAPPING*);
1419 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1420 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
1421
1422 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
1423 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams(RTL_USER_PROCESS_PARAMETERS*);
1424 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
1425 ULONG     WINAPI RtlNtStatusToDosErrorNoTeb(NTSTATUS);
1426 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1427 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1428
1429 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
1430 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
1431 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1432 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHKEY);
1433
1434 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
1435 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1436
1437 NTSTATUS  WINAPI RtlQueryEnvironmentVariable_U(PWSTR,PUNICODE_STRING,PUNICODE_STRING);
1438 NTSTATUS  WINAPI RtlQueryInformationAcl(PACL,LPVOID,DWORD,ACL_INFORMATION_CLASS);
1439 NTSTATUS  WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1440
1441 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
1442 void      WINAPI RtlRaiseStatus(NTSTATUS);
1443 ULONG     WINAPI RtlRandom(PULONG);
1444 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
1445 void      WINAPI RtlReleasePebLock(void);
1446 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
1447 ULONG     WINAPI RtlRemoveVectoredExceptionHandler(PVOID);
1448 void      WINAPI RtlRestoreLastWin32Error(DWORD);
1449
1450 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
1451 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
1452 NTSTATUS  WINAPI RtlSelfRelativeToAbsoluteSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,
1453                                              PDWORD,PACL,PDWORD,PACL,PDWORD,PSID,PDWORD,PSID,PDWORD);
1454 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
1455 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1456 NTSTATUS  WINAPI RtlSetCurrentDirectory_U(const UNICODE_STRING*);
1457 void      WINAPI RtlSetCurrentEnvironment(PWSTR, PWSTR*);
1458 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1459 NTSTATUS  WINAPI RtlSetEnvironmentVariable(PWSTR*,PUNICODE_STRING,PUNICODE_STRING);
1460 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1461 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1462 void      WINAPI RtlSetLastWin32Error(DWORD);
1463 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1464 NTSTATUS  WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
1465 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
1466 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
1467 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
1468 NTSTATUS  WINAPI RtlSystemTimeToLocalTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1469
1470 void      WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
1471 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
1472 void      WINAPI RtlTimeToElapsedTimeFields(const LARGE_INTEGER *,PTIME_FIELDS);
1473 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,LPDWORD);
1474 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
1475 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
1476
1477 ULONGLONG __cdecl RtlUlonglongByteSwap(ULONGLONG);
1478 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
1479 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
1480 NTSTATUS  WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING *,ULONG,ULONG *);
1481 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
1482 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
1483 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1484 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
1485 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1486 ULONG     WINAPI RtlUniform(PULONG);
1487 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
1488 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
1489 #ifdef __ia64__
1490 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
1491 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1492 #endif
1493 WCHAR     WINAPI RtlUpcaseUnicodeChar(WCHAR);
1494 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1495 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1496 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToCountedOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1497 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1498 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1499 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1500 CHAR      WINAPI RtlUpperChar(CHAR);
1501 void      WINAPI RtlUpperString(STRING *,const STRING *);
1502
1503 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1504 BOOLEAN   WINAPI RtlValidAcl(PACL);
1505 BOOLEAN   WINAPI RtlValidSid(PSID);
1506 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1507 NTSTATUS  WINAPI RtlVerifyVersionInfo(const RTL_OSVERSIONINFOEXW*,DWORD,DWORDLONG);
1508
1509 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1510
1511 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1512 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1513
1514 /* Wine internal functions */
1515
1516 extern NTSTATUS wine_nt_to_unix_file_name( const UNICODE_STRING *nameW, ANSI_STRING *unix_name_ret,
1517                                            UINT disposition, BOOLEAN check_case );
1518
1519 /***********************************************************************
1520  * Inline functions
1521  */
1522
1523 #define InitializeObjectAttributes(p,n,a,r,s) \
1524     do { \
1525         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1526         (p)->RootDirectory = r; \
1527         (p)->Attributes = a; \
1528         (p)->ObjectName = n; \
1529         (p)->SecurityDescriptor = s; \
1530         (p)->SecurityQualityOfService = NULL; \
1531     } while (0)
1532
1533 #define NtCurrentProcess() ((HANDLE)-1)
1534
1535 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1536 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1537 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1538 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1539 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1540 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1541 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1542
1543 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1544 {
1545     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1546         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1547         return TRUE;
1548     return FALSE;
1549 }
1550
1551 #define RtlClearAllBits(p) \
1552     do { \
1553         PRTL_BITMAP _p = (p); \
1554         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1555     } while (0)
1556
1557 #define RtlInitializeBitMap(p,b,s) \
1558     do { \
1559         PRTL_BITMAP _p = (p); \
1560         _p->SizeOfBitMap = (s); \
1561         _p->BitMapBuffer = (b); \
1562     } while (0)
1563
1564 #define RtlSetAllBits(p) \
1565     do { \
1566         PRTL_BITMAP _p = (p); \
1567         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1568     } while (0)
1569
1570 /* These are implemented as __fastcall, so we can't let Winelib apps link with them */
1571 inline static USHORT RtlUshortByteSwap(USHORT s)
1572 {
1573     return (s >> 8) | (s << 8);
1574 }
1575 inline static ULONG RtlUlongByteSwap(ULONG i)
1576 {
1577 #if defined(__i386__) && defined(__GNUC__)
1578     ULONG ret;
1579     __asm__("bswap %0" : "=r" (ret) : "0" (i) );
1580     return ret;
1581 #else
1582     return ((ULONG)RtlUshortByteSwap((USHORT)i) << 16) | RtlUshortByteSwap((USHORT)(i >> 16));
1583 #endif
1584 }
1585
1586 /*************************************************************************
1587  * Loader functions and structures.
1588  *
1589  * Those are not part of standard Winternl.h
1590  */
1591 typedef struct _LDR_MODULE
1592 {
1593     LIST_ENTRY          InLoadOrderModuleList;
1594     LIST_ENTRY          InMemoryOrderModuleList;
1595     LIST_ENTRY          InInitializationOrderModuleList;
1596     void*               BaseAddress;
1597     void*               EntryPoint;
1598     ULONG               SizeOfImage;
1599     UNICODE_STRING      FullDllName;
1600     UNICODE_STRING      BaseDllName;
1601     ULONG               Flags;
1602     SHORT               LoadCount;
1603     SHORT               TlsIndex;
1604     HANDLE              SectionHandle;
1605     ULONG               CheckSum;
1606     ULONG               TimeDateStamp;
1607 } LDR_MODULE, *PLDR_MODULE;
1608
1609 /* those defines are (some of the) regular LDR_MODULE.Flags values */
1610 #define LDR_IMAGE_IS_DLL                0x00000004
1611 #define LDR_LOAD_IN_PROGRESS            0x00001000
1612 #define LDR_UNLOAD_IN_PROGRESS          0x00002000
1613 #define LDR_NO_DLL_CALLS                0x00040000
1614 #define LDR_PROCESS_ATTACHED            0x00080000
1615 #define LDR_MODULE_REBASED              0x00200000
1616
1617 /* these ones is Wine specific */
1618 #define LDR_DONT_RESOLVE_REFS           0x40000000
1619 #define LDR_WINE_INTERNAL               0x80000000
1620
1621 /* FIXME: to be checked */
1622 #define MAXIMUM_FILENAME_LENGTH 256
1623
1624 typedef struct _SYSTEM_MODULE
1625 {
1626     ULONG               Reserved1;
1627     ULONG               Reserved2;
1628     PVOID               ImageBaseAddress;
1629     ULONG               ImageSize;
1630     ULONG               Flags;
1631     WORD                Id;
1632     WORD                Rank;
1633     WORD                Unknown;
1634     WORD                NameOffset;
1635     BYTE                Name[MAXIMUM_FILENAME_LENGTH];
1636 } SYSTEM_MODULE, *PSYSTEM_MODULE;
1637
1638 typedef struct _SYSTEM_MODULE_INFORMATION
1639 {
1640     ULONG               ModulesCount;
1641     SYSTEM_MODULE       Modules[1]; /* FIXME: should be Modules[0] */
1642 } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
1643
1644 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE);
1645 NTSTATUS WINAPI LdrFindEntryForAddress(const void*, PLDR_MODULE*);
1646 NTSTATUS WINAPI LdrLockLoaderLock(ULONG,ULONG*,ULONG*);
1647 NTSTATUS WINAPI LdrQueryProcessModuleInformation(SYSTEM_MODULE_INFORMATION*, ULONG, ULONG*);
1648 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
1649 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
1650
1651 /* list manipulation macros */
1652 #define InitializeListHead(le)  (void)((le)->Flink = (le)->Blink = (le))
1653 #define InsertHeadList(le,e)    do { PLIST_ENTRY f = (le)->Flink; (e)->Flink = f; (e)->Blink = (le); f->Blink = (e); (le)->Flink = (e); } while (0)
1654 #define InsertTailList(le,e)    do { PLIST_ENTRY b = (le)->Blink; (e)->Flink = (le); (e)->Blink = b; b->Flink = (e); (le)->Blink = (e); } while (0)
1655 #define IsListEmpty(le)         ((le)->Flink == (le))
1656 #define RemoveEntryList(e)      do { PLIST_ENTRY f = (e)->Flink, b = (e)->Blink; f->Blink = b; b->Flink = f; (e)->Flink = (e)->Blink = NULL; } while (0)
1657 static inline PLIST_ENTRY RemoveHeadList(PLIST_ENTRY le)
1658 {
1659     PLIST_ENTRY f, b, e;
1660
1661     e = le->Flink;
1662     f = le->Flink->Flink;
1663     b = le->Flink->Blink;
1664     f->Blink = b;
1665     b->Flink = f;
1666
1667     if (e != le) e->Flink = e->Blink = NULL;
1668     return e;
1669 }
1670 static inline PLIST_ENTRY RemoveTailList(PLIST_ENTRY le)
1671 {
1672     PLIST_ENTRY f, b, e;
1673
1674     e = le->Blink;
1675     f = le->Blink->Flink;
1676     b = le->Blink->Blink;
1677     f->Blink = b;
1678     b->Flink = f;
1679
1680     if (e != le) e->Flink = e->Blink = NULL;
1681     return e;
1682 }
1683
1684 #ifdef __cplusplus
1685 } /* extern "C" */
1686 #endif /* defined(__cplusplus) */
1687
1688 #endif  /* __WINE_WINTERNAL_H */