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