include/winternl.h

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