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      DesktopInfo;
 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 NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 940 NTSTATUS  WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
 941 NTSTATUS  WINAPI NtNotifyChangeKey(HKEY,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
 942 NTSTATUS  WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 943 NTSTATUS  WINAPI NtOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
 944 NTSTATUS  WINAPI NtOpenKey(PHKEY,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 945 NTSTATUS  WINAPI NtOpenProcessToken(HANDLE,DWORD,HANDLE *);
 946 NTSTATUS  WINAPI NtOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 947 NTSTATUS  WINAPI NtOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
 948 NTSTATUS  WINAPI NtOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
 949 NTSTATUS  WINAPI NtOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
 950 NTSTATUS  WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
 951 NTSTATUS  WINAPI NtPulseEvent(HANDLE,PULONG);
 952 NTSTATUS  WINAPI NtQueueApcThread(HANDLE,PNTAPCFUNC,ULONG_PTR,ULONG_PTR,ULONG_PTR);
 953 NTSTATUS  WINAPI NtQueryDefaultLocale(BOOLEAN,LCID*);
 954 NTSTATUS  WINAPI NtQueryInformationProcess(HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);
 955 NTSTATUS  WINAPI NtQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
 956 NTSTATUS  WINAPI NtQueryInformationToken(HANDLE,DWORD,LPVOID,DWORD,LPDWORD);
 957 NTSTATUS  WINAPI NtQueryKey(HKEY,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 958 NTSTATUS  WINAPI NtQueryMultipleValueKey(HKEY,PVALENTW,ULONG,PVOID,ULONG,PULONG);
 959 NTSTATUS  WINAPI NtQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
 960 NTSTATUS  WINAPI NtQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
 961 NTSTATUS  WINAPI NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 962 NTSTATUS  WINAPI NtQuerySystemTime(PLARGE_INTEGER);
 963 NTSTATUS  WINAPI NtQueryValueKey(HKEY,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
 964 NTSTATUS  WINAPI NtQueryVirtualMemory(HANDLE,LPCVOID,MEMORY_INFORMATION_CLASS,PVOID,ULONG,ULONG*);
 965 void      WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
 966 NTSTATUS  WINAPI NtReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
 967 NTSTATUS  WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
 968 NTSTATUS  WINAPI NtReplaceKey(POBJECT_ATTRIBUTES,HKEY,POBJECT_ATTRIBUTES);
 969 NTSTATUS  WINAPI NtResetEvent(HANDLE,PULONG);
 970 NTSTATUS  WINAPI NtRestoreKey(HKEY,HANDLE,ULONG);
 971 NTSTATUS  WINAPI NtResumeThread(HANDLE,PULONG);
 972 NTSTATUS  WINAPI NtSaveKey(HKEY,HANDLE);
 973 NTSTATUS  WINAPI NtSetContextThread(HANDLE,const CONTEXT*);
 974 NTSTATUS  WINAPI NtSetDefaultLocale(BOOLEAN,LCID);
 975 NTSTATUS  WINAPI NtSetEvent(HANDLE,PULONG);
 976 NTSTATUS  WINAPI NtSetInformationKey(HKEY,const int,PVOID,ULONG);
 977 NTSTATUS  WINAPI NtSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
 978 NTSTATUS  WINAPI NtSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 979 NTSTATUS  WINAPI NtSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
 980 NTSTATUS  WINAPI NtSetTimer(HANDLE, const LARGE_INTEGER*, PTIMERAPCROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
 981 NTSTATUS  WINAPI NtSetValueKey(HKEY,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
 982 NTSTATUS  WINAPI NtSuspendThread(HANDLE,PULONG);
 983 NTSTATUS  WINAPI NtTerminateProcess(HANDLE,LONG);
 984 NTSTATUS  WINAPI NtTerminateThread(HANDLE,LONG);
 985 NTSTATUS  WINAPI NtUnloadKey(HKEY);
 986 NTSTATUS  WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 987 NTSTATUS  WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
 988 NTSTATUS  WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,PLARGE_INTEGER);
 989 NTSTATUS  WINAPI NtWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,PLARGE_INTEGER);
 990
 991 void      WINAPI RtlAcquirePebLock(void);
 992 BYTE      WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK,BYTE);
 993 BYTE      WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK,BYTE);
 994 NTSTATUS  WINAPI RtlAddAce(PACL,DWORD,DWORD,PACE_HEADER,DWORD);
 995 NTSTATUS  WINAPI RtlAddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
 996 BOOL      WINAPI RtlAddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
 997 NTSTATUS  WINAPI RtlAddAccessDeniedAce(PACL,DWORD,DWORD,PSID);
 998 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
 999 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
1000 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
1001 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
1002 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
1003 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
1004 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
1005 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
1006 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
1007 BOOLEAN   WINAPI RtlAreAllAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1008 BOOLEAN   WINAPI RtlAreAnyAccessesGranted(ACCESS_MASK,ACCESS_MASK);
1009 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
1010 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
1011
1012 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
1013 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
1014 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
1015 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
1016 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
1017 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1018 DWORD     WINAPI RtlComputeCrc32(DWORD,PBYTE,INT);
1019 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
1020 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
1021 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
1022 void      WINAPI RtlCopyLuid(PLUID,const LUID*);
1023 void      WINAPI RtlCopyLuidAndAttributesArray(ULONG,const LUID_AND_ATTRIBUTES*,PLUID_AND_ATTRIBUTES);
1024 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
1025 void      WINAPI RtlCopyString(STRING*,const STRING*);
1026 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
1027 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
1028 NTSTATUS  WINAPI RtlCreateEnvironment(BOOLEAN, PWSTR*);
1029 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
1030 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
1031 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
1032 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
1033
1034 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
1035 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
1036 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
1037 NTSTATUS  WINAPI RtlDestroyEnvironment(PWSTR);
1038 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
1039 DOS_PATHNAME_TYPE WINAPI RtlDetermineDosPathNameType_U(PCWSTR);
1040 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(LPWSTR,PUNICODE_STRING,PWSTR*,CURDIR*);
1041 WCHAR     WINAPI RtlDowncaseUnicodeChar(WCHAR);
1042 NTSTATUS  WINAPI RtlDowncaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1043 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
1044 NTSTATUS  WINAPI RtlDuplicateUnicodeString(int,const UNICODE_STRING*,UNICODE_STRING*);
1045
1046 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
1047 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
1048 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
1049 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
1050 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
1051 NTSTATUS  WINAPI RtlEqualComputerName(const UNICODE_STRING*,const UNICODE_STRING*);
1052 NTSTATUS  WINAPI RtlEqualDomainName(const UNICODE_STRING*,const UNICODE_STRING*);
1053 BOOLEAN   WINAPI RtlEqualLuid(const LUID*,const LUID*);
1054 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
1055 BOOL      WINAPI RtlEqualSid(PSID,PSID);
1056 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
1057 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1058 NTSTATUS  WINAPI RtlExpandEnvironmentStrings_U(PWSTR, const UNICODE_STRING*, UNICODE_STRING*, ULONG*);
1059 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
1060 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
1061 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
1062
1063 NTSTATUS  WINAPI RtlFindCharInUnicodeString(int,const UNICODE_STRING*,const UNICODE_STRING*,USHORT*);
1064 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
1065 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
1066 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1067 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1068 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1069 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
1070 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
1071 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
1072 NTSTATUS  WINAPI RtlFindMessage(HMODULE,ULONG,ULONG,ULONG,const MESSAGE_RESOURCE_ENTRY**);
1073 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
1074 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1075 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1076 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
1077 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
1078 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1079 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
1080 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
1081 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
1082 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
1083 void      WINAPI RtlFreeOemString(POEM_STRING);
1084 DWORD     WINAPI RtlFreeSid(PSID);
1085 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
1086
1087 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
1088 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
1089 NTSTATUS  WINAPI RtlGetCurrentDirectory_U(ULONG, LPWSTR);
1090 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1091 ULONG     WINAPI RtlGetFullPathName_U(PCWSTR,ULONG,PWSTR,PWSTR*);
1092 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1093 DWORD     WINAPI RtlGetLongestNtPathLength(void);
1094 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
1095 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
1096 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
1097 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
1098
1099 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
1100 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
1101 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
1102 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
1103 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
1104 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
1105 void      WINAPI RtlInitString(PSTRING,PCSZ);
1106 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
1107 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
1108 NTSTATUS  WINAPI RtlInitUnicodeStringEx(PUNICODE_STRING,PCWSTR);
1109 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
1110 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
1111 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1112 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
1113 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
1114
1115 NTSTATUS  WINAPI RtlInt64ToUnicodeString(ULONGLONG,ULONG,UNICODE_STRING *);
1116 NTSTATUS  WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
1117 NTSTATUS  WINAPI RtlIntegerToUnicodeString(ULONG,ULONG,UNICODE_STRING *);
1118 ULONG     WINAPI RtlIsDosDeviceName_U(PCWSTR);
1119 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
1120 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
1121
1122 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
1123 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
1124 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
1125 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
1126 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
1127 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
1128 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
1129 NTSTATUS  WINAPI RtlLargeIntegerToChar(const ULONGLONG *,ULONG,ULONG,PCHAR);
1130 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
1131 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
1132 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
1133 DWORD     WINAPI RtlLengthSid(PSID);
1134 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1135 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
1136
1137 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
1138 void      WINAPI RtlMapGenericMask(PACCESS_MASK,const GENERIC_MAPPING*);
1139 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1140 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
1141
1142 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
1143 LPVOID    WINAPI RtlNormalizeProcessParams(LPVOID);
1144 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
1145 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1146 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1147
1148 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
1149 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
1150 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
1151 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHKEY);
1152
1153 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
1154 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
1155
1156 NTSTATUS  WINAPI RtlQueryEnvironmentVariable_U(PWSTR,PUNICODE_STRING,PUNICODE_STRING);
1157 NTSTATUS  WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1158
1159 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
1160 void      WINAPI RtlRaiseStatus(NTSTATUS);
1161 ULONG     WINAPI RtlRandom(PULONG);
1162 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
1163 void      WINAPI RtlReleasePebLock(void);
1164 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
1165
1166 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
1167 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
1168 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
1169 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1170 NTSTATUS  WINAPI RtlSetCurrentDirectory_U(const UNICODE_STRING*);
1171 void      WINAPI RtlSetCurrentEnvironment(PWSTR, PWSTR*);
1172 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1173 NTSTATUS  WINAPI RtlSetEnvironmentVariable(PWSTR*,PUNICODE_STRING,PUNICODE_STRING);
1174 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1175 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
1176 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
1177 NTSTATUS  WINAPI RtlSetTimeZoneInformation(const TIME_ZONE_INFORMATION*);
1178 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
1179 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
1180 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
1181 NTSTATUS  WINAPI RtlSystemTimeToLocalTime(const LARGE_INTEGER*,PLARGE_INTEGER);
1182
1183 void      WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
1184 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
1185 void      WINAPI RtlTimeToElapsedTimeFields(const LARGE_INTEGER *,PTIME_FIELDS);
1186 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,PULONG);
1187 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
1188 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
1189
1190 ULONGLONG __cdecl RtlUlonglongByteSwap(ULONGLONG);
1191 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
1192 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
1193 NTSTATUS  WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING *,ULONG,ULONG *);
1194 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
1195 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
1196 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1197 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
1198 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1199 ULONG     WINAPI RtlUniform(PULONG);
1200 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
1201 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
1202 #ifdef __ia64__
1203 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
1204 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1205 #endif
1206 WCHAR     WINAPI RtlUpcaseUnicodeChar(WCHAR);
1207 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1208 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1209 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToCountedOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1210 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1211 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1212 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1213 CHAR      WINAPI RtlUpperChar(CHAR);
1214 void      WINAPI RtlUpperString(STRING *,const STRING *);
1215
1216 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1217 BOOLEAN   WINAPI RtlValidAcl(PACL);
1218 BOOLEAN   WINAPI RtlValidSid(PSID);
1219 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1220
1221 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1222
1223 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1224 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1225
1226 /***********************************************************************
1227  * Inline functions
1228  */
1229
1230 #define InitializeObjectAttributes(p,n,a,r,s) \
1231     do { \
1232         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1233         (p)->RootDirectory = r; \
1234         (p)->Attributes = a; \
1235         (p)->ObjectName = n; \
1236         (p)->SecurityDescriptor = s; \
1237         (p)->SecurityQualityOfService = NULL; \
1238     } while (0)
1239
1240 #define NtCurrentProcess() ((HANDLE)-1)
1241
1242 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1243 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1244 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1245 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1246 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1247 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1248 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1249
1250 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1251 {
1252     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1253         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1254         return TRUE;
1255     return FALSE;
1256 }
1257
1258 #define RtlClearAllBits(p) \
1259     do { \
1260         PRTL_BITMAP _p = (p); \
1261         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1262     } while (0)
1263
1264 #define RtlInitializeBitMap(p,b,s) \
1265     do { \
1266         PRTL_BITMAP _p = (p); \
1267         _p->SizeOfBitMap = (s); \
1268         _p->BitMapBuffer = (b); \
1269     } while (0)
1270
1271 #define RtlSetAllBits(p) \
1272     do { \
1273         PRTL_BITMAP _p = (p); \
1274         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1275     } while (0)
1276
1277 /* These are implemented as __fastcall, so we can't let Winelib apps link with them */
1278 inline static USHORT RtlUshortByteSwap(USHORT s)
1279 {
1280     return (s >> 8) | (s << 8);
1281 }
1282 inline static ULONG RtlUlongByteSwap(ULONG i)
1283 {
1284 #if defined(__i386__) && defined(__GNUC__)
1285     ULONG ret;
1286     __asm__("bswap %0" : "=r" (ret) : "0" (i) );
1287     return ret;
1288 #else
1289     return ((ULONG)RtlUshortByteSwap(i) << 16) | RtlUshortByteSwap(i >> 16);
1290 #endif
1291 }
1292
1293 /*************************************************************************
1294  * Loader functions and structures.
1295  *
1296  * Those are not part of standard Winternl.h
1297  */
1298 typedef struct _LDR_MODULE
1299 {
1300     LIST_ENTRY          InLoadOrderModuleList;
1301     LIST_ENTRY          InMemoryOrderModuleList;
1302     LIST_ENTRY          InInitializationOrderModuleList;
1303     void*               BaseAddress;
1304     void*               EntryPoint;
1305     ULONG               SizeOfImage;
1306     UNICODE_STRING      FullDllName;
1307     UNICODE_STRING      BaseDllName;
1308     ULONG               Flags;
1309     SHORT               LoadCount;
1310     SHORT               TlsIndex;
1311     HANDLE              SectionHandle;
1312     ULONG               CheckSum;
1313     ULONG               TimeDateStamp;
1314 } LDR_MODULE, *PLDR_MODULE;
1315
1316 /* those defines are (some of the) regular LDR_MODULE.Flags values */
1317 #define LDR_IMAGE_IS_DLL                0x00000004
1318 #define LDR_LOAD_IN_PROGRESS            0x00001000
1319 #define LDR_UNLOAD_IN_PROGRESS          0x00002000
1320 #define LDR_NO_DLL_CALLS                0x00040000
1321 #define LDR_PROCESS_ATTACHED            0x00080000
1322 #define LDR_MODULE_REBASED              0x00200000
1323
1324 /* these ones is Wine specific */
1325 #define LDR_DONT_RESOLVE_REFS           0x40000000
1326 #define LDR_WINE_INTERNAL               0x80000000
1327
1328 /* FIXME: to be checked */
1329 #define MAXIMUM_FILENAME_LENGTH 256
1330
1331 typedef struct _SYSTEM_MODULE
1332 {
1333     ULONG               Reserved1;
1334     ULONG               Reserved2;
1335     PVOID               ImageBaseAddress;
1336     ULONG               ImageSize;
1337     ULONG               Flags;
1338     WORD                Id;
1339     WORD                Rank;
1340     WORD                Unknown;
1341     WORD                NameOffset;
1342     BYTE                Name[MAXIMUM_FILENAME_LENGTH];
1343 } SYSTEM_MODULE, *PSYSTEM_MODULE;
1344
1345 typedef struct _SYSTEM_MODULE_INFORMATION
1346 {
1347     ULONG               ModulesCount;
1348     SYSTEM_MODULE       Modules[1]; /* FIXME: should be Modules[0] */
1349 } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
1350
1351 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE);
1352 NTSTATUS WINAPI LdrFindEntryForAddress(const void*, PLDR_MODULE*);
1353 NTSTATUS WINAPI LdrGetDllHandle(ULONG, ULONG, PUNICODE_STRING, HMODULE*);
1354 NTSTATUS WINAPI LdrGetProcedureAddress(HMODULE, PANSI_STRING, ULONG, void**);
1355 NTSTATUS WINAPI LdrLoadDll(LPCWSTR, DWORD, PUNICODE_STRING, HMODULE*);
1356 NTSTATUS WINAPI LdrLockLoaderLock(ULONG,ULONG*,ULONG*);
1357 NTSTATUS WINAPI LdrQueryProcessModuleInformation(SYSTEM_MODULE_INFORMATION*, ULONG, ULONG*);
1358 NTSTATUS WINAPI LdrUnloadDll(HMODULE);
1359 NTSTATUS WINAPI LdrUnlockLoaderLock(ULONG,ULONG);
1360
1361 #ifdef __cplusplus
1362 } /* extern "C" */
1363 #endif /* defined(__cplusplus) */
1364
1365 #endif  /* __WINE_WINTERNAL_H */