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

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