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 PVOID     WINAPI RtlAddVectoredExceptionHandler(ULONG,PVECTORED_EXCEPTION_HANDLER);
1058 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
1059 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
1060 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
1061 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
1062 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
1063 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
1064 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
1065 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
1066 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
1067 BOOLEAN   WINAPI RtlAreAllAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1068 BOOLEAN   WINAPI RtlAreAnyAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1069 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
1070 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
1071
1072 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
1073 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
1074 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
1075 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
1076 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
1077 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1078 DWORD     WINAPI RtlComputeCrc32(DWORD,PBYTE,INT);
1079 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
1080 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
1081 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
1082 void      WINAPI RtlCopyLuid(PLUID,const LUID*);
1083 void      WINAPI RtlCopyLuidAndAttributesArray(ULONG,const LUID_AND_ATTRIBUTES*,PLUID_AND_ATTRIBUTES);
1084 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
1085 void      WINAPI RtlCopyString(STRING*,const STRING*);
1086 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
1087 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
1088 NTSTATUS  WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
1089 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
1090 NTSTATUS  WINAPI RtlCreateProcessParameters(RTL_USER_PROCESS_PARAMETERS**,const UNICODE_STRING*,
1091                                             const UNICODE_STRING*,const UNICODE_STRING*,
1092                                             const UNICODE_STRING*,PWSTR,const UNICODE_STRING*,
1093                                             const UNICODE_STRING*,const UNICODE_STRING*,
1094                                             const UNICODE_STRING*);
1095 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
1096 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
1097 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
1098
1099 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
1100 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
1101 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
1102 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams(RTL_USER_PROCESS_PARAMETERS*);
1103 NTSTATUS  WINAPI RtlDestroyEnvironment(PWSTR);
1104 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
1105 void      WINAPI RtlDestroyProcessParameters(RTL_USER_PROCESS_PARAMETERS*);
1106 DOS_PATHNAME_TYPE WINAPI RtlDetermineDosPathNameType_U(PCWSTR);
1107 BOOLEAN   WINAPI RtlDoesFileExists_U(LPCWSTR);
1108 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(LPWSTR,PUNICODE_STRING,PWSTR*,CURDIR*);
1109 ULONG     WINAPI RtlDosSearchPath_U(LPCWSTR, LPCWSTR, LPCWSTR, ULONG, LPWSTR, LPWSTR*);
1110 WCHAR     WINAPI RtlDowncaseUnicodeChar(WCHAR);
1111 NTSTATUS  WINAPI RtlDowncaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1112 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
1113 NTSTATUS  WINAPI RtlDuplicateUnicodeString(int,const UNICODE_STRING*,UNICODE_STRING*);
1114
1115 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
1116 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
1117 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
1118 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
1119 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
1120 NTSTATUS  WINAPI RtlEqualComputerName(const UNICODE_STRING*,const UNICODE_STRING*);
1121 NTSTATUS  WINAPI RtlEqualDomainName(const UNICODE_STRING*,const UNICODE_STRING*);
1122 BOOLEAN   WINAPI RtlEqualLuid(const LUID*,const LUID*);
1123 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
1124 BOOL      WINAPI RtlEqualSid(PSID,PSID);
1125 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
1126 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1127 NTSTATUS  WINAPI RtlExpandEnvironmentStrings_U(PWSTR, const UNICODE_STRING*, UNICODE_STRING*, ULONG*);
1128 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
1129 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
1130 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
1131
1132 NTSTATUS  WINAPI RtlFindCharInUnicodeString(int,const UNICODE_STRING*,const UNICODE_STRING*,USHORT*);
1133 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
1134 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
1135 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1136 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1137 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1138 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
1139 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
1140 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
1141 NTSTATUS  WINAPI RtlFindMessage(HMODULE,ULONG,ULONG,ULONG,const MESSAGE_RESOURCE_ENTRY**);
1142 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
1143 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1144 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1145 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
1146 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
1147 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1148 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
1149 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
1150 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
1151 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
1152 void      WINAPI RtlFreeOemString(POEM_STRING);
1153 DWORD     WINAPI RtlFreeSid(PSID);
1154 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
1155
1156 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
1157 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
1158 NTSTATUS  WINAPI RtlGetCurrentDirectory_U(ULONG, LPWSTR);
1159 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1160 ULONG     WINAPI RtlGetFullPathName_U(PCWSTR,ULONG,PWSTR,PWSTR*);
1161 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1162 DWORD     WINAPI RtlGetLongestNtPathLength(void);
1163 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
1164 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1165 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
1166 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1167 NTSTATUS  WINAPI RtlGetVersion(RTL_OSVERSIONINFOEXW*);
1168
1169 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
1170 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
1171 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
1172 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
1173 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
1174 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
1175 void      WINAPI RtlInitString(PSTRING,PCSZ);
1176 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
1177 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
1178 NTSTATUS  WINAPI RtlInitUnicodeStringEx(PUNICODE_STRING,PCWSTR);
1179 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
1180 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
1181 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1182 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
1183 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
1184
1185 NTSTATUS  WINAPI RtlInt64ToUnicodeString(ULONGLONG,ULONG,UNICODE_STRING *);
1186 NTSTATUS  WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
1187 NTSTATUS  WINAPI RtlIntegerToUnicodeString(ULONG,ULONG,UNICODE_STRING *);
1188 ULONG     WINAPI RtlIsDosDeviceName_U(PCWSTR);
1189 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
1190 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
1191
1192 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
1193 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
1194 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
1195 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
1196 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
1197 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
1198 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
1199 NTSTATUS  WINAPI RtlLargeIntegerToChar(const ULONGLONG *,ULONG,ULONG,PCHAR);
1200 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
1201 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
1202 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
1203 DWORD     WINAPI RtlLengthSid(PSID);
1204 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1205 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
1206
1207 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
1208 void      WINAPI RtlMapGenericMask(PACCESS_MASK,const GENERIC_MAPPING*);
1209 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1210 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
1211
1212 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
1213 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams(RTL_USER_PROCESS_PARAMETERS*);
1214 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
1215 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1216 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1217
1218 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
1219 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
1220 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1221 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHKEY);
1222
1223 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
1224 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1225
1226 NTSTATUS  WINAPI RtlQueryEnvironmentVariable_U(PWSTR,PUNICODE_STRING,PUNICODE_STRING);
1227 NTSTATUS  WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1228
1229 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
1230 void      WINAPI RtlRaiseStatus(NTSTATUS);
1231 ULONG     WINAPI RtlRandom(PULONG);
1232 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
1233 void      WINAPI RtlReleasePebLock(void);
1234 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
1235 ULONG     WINAPI RtlRemoveVectoredExceptionHandler(PVOID);
1236
1237 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
1238 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
1239 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
1240 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1241 NTSTATUS  WINAPI RtlSetCurrentDirectory_U(const UNICODE_STRING*);
1242 void      WINAPI RtlSetCurrentEnvironment(PWSTR, PWSTR*);
1243 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1244 NTSTATUS  WINAPI RtlSetEnvironmentVariable(PWSTR*,PUNICODE_STRING,PUNICODE_STRING);
1245 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1246 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1247 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1248 NTSTATUS  WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
1249 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
1250 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
1251 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
1252 NTSTATUS  WINAPI RtlSystemTimeToLocalTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1253
1254 void      WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
1255 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
1256 void      WINAPI RtlTimeToElapsedTimeFields(const LARGE_INTEGER *,PTIME_FIELDS);
1257 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,LPDWORD);
1258 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
1259 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
1260
1261 ULONGLONG __cdecl RtlUlonglongByteSwap(ULONGLONG);
1262 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
1263 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
1264 NTSTATUS  WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING *,ULONG,ULONG *);
1265 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
1266 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
1267 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1268 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
1269 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1270 ULONG     WINAPI RtlUniform(PULONG);
1271 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
1272 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
1273 #ifdef __ia64__
1274 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
1275 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1276 #endif
1277 WCHAR     WINAPI RtlUpcaseUnicodeChar(WCHAR);
1278 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1279 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1280 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToCountedOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1281 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1282 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1283 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1284 CHAR      WINAPI RtlUpperChar(CHAR);
1285 void      WINAPI RtlUpperString(STRING *,const STRING *);
1286
1287 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1288 BOOLEAN   WINAPI RtlValidAcl(PACL);
1289 BOOLEAN   WINAPI RtlValidSid(PSID);
1290 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1291 NTSTATUS  WINAPI RtlVerifyVersionInfo(const RTL_OSVERSIONINFOEXW*,DWORD,DWORDLONG);
1292
1293 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1294
1295 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1296 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1297
1298 /***********************************************************************
1299  * Inline functions
1300  */
1301
1302 #define InitializeObjectAttributes(p,n,a,r,s) \
1303     do { \
1304         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1305         (p)->RootDirectory = r; \
1306         (p)->Attributes = a; \
1307         (p)->ObjectName = n; \
1308         (p)->SecurityDescriptor = s; \
1309         (p)->SecurityQualityOfService = NULL; \
1310     } while (0)
1311
1312 #define NtCurrentProcess() ((HANDLE)-1)
1313
1314 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1315 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1316 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1317 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1318 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1319 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1320 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1321
1322 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1323 {
1324     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1325         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1326         return TRUE;
1327     return FALSE;
1328 }
1329
1330 #define RtlClearAllBits(p) \
1331     do { \
1332         PRTL_BITMAP _p = (p); \
1333         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1334     } while (0)
1335
1336 #define RtlInitializeBitMap(p,b,s) \
1337     do { \
1338         PRTL_BITMAP _p = (p); \
1339         _p->SizeOfBitMap = (s); \
1340         _p->BitMapBuffer = (b); \
1341     } while (0)
1342
1343 #define RtlSetAllBits(p) \
1344     do { \
1345         PRTL_BITMAP _p = (p); \
1346         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1347     } while (0)
1348
1349 /* These are implemented as __fastcall, so we can't let Winelib apps link with them */
1350 inline static USHORT RtlUshortByteSwap(USHORT s)
1351 {
1352     return (s >> 8) | (s << 8);
1353 }
1354 inline static ULONG RtlUlongByteSwap(ULONG i)
1355 {
1356 #if defined(__i386__) && defined(__GNUC__)
1357     ULONG ret;
1358     __asm__("bswap %0" : "=r" (ret) : "0" (i) );
1359     return ret;
1360 #else
1361     return ((ULONG)RtlUshortByteSwap((USHORT)i) << 16) | RtlUshortByteSwap((USHORT)(i >> 16));
1362 #endif
1363 }
1364
1365 /*************************************************************************
1366  * Loader functions and structures.
1367  *
1368  * Those are not part of standard Winternl.h
1369  */
1370 typedef struct _LDR_MODULE
1371 {
1372     LIST_ENTRY          InLoadOrderModuleList;
1373     LIST_ENTRY          InMemoryOrderModuleList;
1374     LIST_ENTRY          InInitializationOrderModuleList;
1375     void*               BaseAddress;
1376     void*               EntryPoint;
1377     ULONG               SizeOfImage;
1378     UNICODE_STRING      FullDllName;
1379     UNICODE_STRING      BaseDllName;
1380     ULONG               Flags;
1381     SHORT               LoadCount;
1382     SHORT               TlsIndex;
1383     HANDLE              SectionHandle;
1384     ULONG               CheckSum;
1385     ULONG               TimeDateStamp;
1386 } LDR_MODULE, *PLDR_MODULE;
1387
1388 /* those defines are (some of the) regular LDR_MODULE.Flags values */
1389 #define LDR_IMAGE_IS_DLL                0x00000004
1390 #define LDR_LOAD_IN_PROGRESS            0x00001000
1391 #define LDR_UNLOAD_IN_PROGRESS          0x00002000
1392 #define LDR_NO_DLL_CALLS                0x00040000
1393 #define LDR_PROCESS_ATTACHED            0x00080000
1394 #define LDR_MODULE_REBASED              0x00200000
1395
1396 /* these ones is Wine specific */
1397 #define LDR_DONT_RESOLVE_REFS           0x40000000
1398 #define LDR_WINE_INTERNAL               0x80000000
1399
1400 /* FIXME: to be checked */
1401 #define MAXIMUM_FILENAME_LENGTH 256
1402
1403 typedef struct _SYSTEM_MODULE
1404 {
1405     ULONG               Reserved1;
1406     ULONG               Reserved2;
1407     PVOID               ImageBaseAddress;
1408     ULONG               ImageSize;
1409     ULONG               Flags;
1410     WORD                Id;
1411     WORD                Rank;
1412     WORD                Unknown;
1413     WORD                NameOffset;
1414     BYTE                Name[MAXIMUM_FILENAME_LENGTH];
1415 } SYSTEM_MODULE, *PSYSTEM_MODULE;
1416
1417 typedef struct _SYSTEM_MODULE_INFORMATION
1418 {
1419     ULONG               ModulesCount;
1420     SYSTEM_MODULE       Modules[1]; /* FIXME: should be Modules[0] */
1421 } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
1422
1423 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE);
1424 NTSTATUS WINAPI LdrFindEntryForAddress(const void*, PLDR_MODULE*);
1425 NTSTATUS WINAPI LdrLockLoaderLock(ULONG,ULONG*,ULONG*);
1426 NTSTATUS WINAPI LdrQueryProcessModuleInformation(SYSTEM_MODULE_INFORMATION*, ULONG, ULONG*);
1427 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
1428 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
1429
1430 /* list manipulation macros */
1431 #define InitializeListHead(le)  (void)((le)->Flink = (le)->Blink = (le))
1432 #define InsertHeadList(le,e)    do { PLIST_ENTRY f = (le)->Flink; (e)->Flink = f; (e)->Blink = (le); f->Blink = (e); (le)->Flink = (e); } while (0)
1433 #define InsertTailList(le,e)    do { PLIST_ENTRY b = (le)->Blink; (e)->Flink = (le); (e)->Blink = b; b->Flink = (e); (le)->Blink = (e); } while (0)
1434 #define IsListEmpty(le)         ((le)->Flink == (le))
1435 #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)
1436 static inline PLIST_ENTRY RemoveHeadList(PLIST_ENTRY le)
1437 {
1438     PLIST_ENTRY f, b, e;
1439
1440     e = le->Flink;
1441     f = le->Flink->Flink;
1442     b = le->Flink->Blink;
1443     f->Blink = b;
1444     b->Flink = f;
1445
1446     if (e != le) e->Flink = e->Blink = NULL;
1447     return e;
1448 }
1449 static inline PLIST_ENTRY RemoveTailList(PLIST_ENTRY le)
1450 {
1451     PLIST_ENTRY f, b, e;
1452
1453     e = le->Blink;
1454     f = le->Blink->Flink;
1455     b = le->Blink->Blink;
1456     f->Blink = b;
1457     b->Flink = f;
1458
1459     if (e != le) e->Flink = e->Blink = NULL;
1460     return e;
1461 }
1462
1463 #ifdef __cplusplus
1464 } /* extern "C" */
1465 #endif /* defined(__cplusplus) */
1466
1467 #endif  /* __WINE_WINTERNAL_H */