git.oblomov.eu Git - wine/blob - include/winternl.h

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