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