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  * PEB data structure
  34  */
  35 typedef struct _PEB {
  36   BYTE Reserved1[2];
  37   BYTE BeingDebugged;
  38   BYTE Reserved2[229];
  39   PVOID Reserved3[59];
  40   ULONG SessionId;
  41 } PEB, *PPEB;
  42
  43 /***********************************************************************
  44  * TEB data structure
  45  */
  46 #if 0
  47 typedef struct _TEB {
  48   BYTE Reserved1[1952];
  49   PVOID Reserved2[412];
  50   PVOID TlsSlots[64];
  51   BYTE Reserved3[8];
  52   PVOID Reserved4[26];
  53   PVOID ReservedForOle; /* Windows 2000 only */
  54   PVOID Reserved5[4];
  55   PVOID TlsExpansionSlots;
  56 } TEB, *PTEB;
  57 #endif
  58
  59 /**********************************************************************
  60  * Fundamental types and data structures
  61  */
  62
  63 typedef LONG NTSTATUS;
  64
  65 typedef CONST char *PCSZ;
  66
  67 typedef short CSHORT;
  68 typedef CSHORT *PCSHORT;
  69
  70 typedef struct _STRING {
  71   USHORT Length;
  72   USHORT MaximumLength;
  73   PCHAR Buffer;
  74 } STRING, *PSTRING;
  75
  76 typedef STRING ANSI_STRING;
  77 typedef PSTRING PANSI_STRING;
  78 typedef const STRING *PCANSI_STRING;
  79
  80 typedef STRING OEM_STRING;
  81 typedef PSTRING POEM_STRING;
  82 typedef const STRING *PCOEM_STRING;
  83
  84 typedef struct _UNICODE_STRING {
  85   USHORT Length;        /* bytes */
  86   USHORT MaximumLength; /* bytes */
  87   PWSTR  Buffer;
  88 } UNICODE_STRING, *PUNICODE_STRING;
  89
  90 typedef const UNICODE_STRING *PCUNICODE_STRING;
  91
  92 /***********************************************************************
  93  * Enums
  94  */
  95
  96 typedef enum _FILE_INFORMATION_CLASS {
  97     FileDirectoryInformation = 1,
  98     FileFullDirectoryInformation,
  99     FileBothDirectoryInformation,
 100     FileBasicInformation,
 101     FileStandardInformation,
 102     FileInternalInformation,
 103     FileEaInformation,
 104     FileAccessInformation,
 105     FileNameInformation,
 106     FileRenameInformation,
 107     FileLinkInformation,
 108     FileNamesInformation,
 109     FileDispositionInformation,
 110     FilePositionInformation,
 111     FileFullEaInformation,
 112     FileModeInformation,
 113     FileAlignmentInformation,
 114     FileAllInformation,
 115     FileAllocationInformation,
 116     FileEndOfFileInformation,
 117     FileAlternateNameInformation,
 118     FileStreamInformation,
 119     FilePipeInformation,
 120     FilePipeLocalInformation,
 121     FilePipeRemoteInformation,
 122     FileMailslotQueryInformation,
 123     FileMailslotSetInformation,
 124     FileCompressionInformation,
 125     FileObjectIdInformation,
 126     FileCompletionInformation,
 127     FileMoveClusterInformation,
 128     FileQuotaInformation,
 129     FileReparsePointInformation,
 130     FileNetworkOpenInformation,
 131     FileAttributeTagInformation,
 132     FileTrackingInformation,
 133     FileMaximumInformation
 134 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
 135
 136 typedef enum _FSINFOCLASS {
 137     FileFsVolumeInformation = 1,
 138     FileFsLabelInformation,
 139     FileFsSizeInformation,
 140     FileFsDeviceInformation,
 141     FileFsAttributeInformation,
 142     FileFsControlInformation,
 143     FileFsFullSizeInformation,
 144     FileFsObjectIdInformation,
 145     FileFsMaximumInformation
 146 } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
 147
 148 typedef enum _KEY_INFORMATION_CLASS {
 149     KeyBasicInformation,
 150     KeyNodeInformation,
 151     KeyFullInformation
 152 } KEY_INFORMATION_CLASS;
 153
 154 typedef enum _KEY_VALUE_INFORMATION_CLASS {
 155     KeyValueBasicInformation,
 156     KeyValueFullInformation,
 157     KeyValuePartialInformation,
 158     KeyValueFullInformationAlign64,
 159     KeyValuePartialInformationAlign64
 160 } KEY_VALUE_INFORMATION_CLASS;
 161
 162 typedef enum _OBJECT_INFORMATION_CLASS {
 163     DunnoTheConstants1 /* FIXME */
 164 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
 165
 166 typedef enum _PROCESSINFOCLASS {
 167     ProcessBasicInformation = 0,
 168     ProcessQuotaLimits = 1,
 169     ProcessIoCounters = 2,
 170     ProcessVmCounters = 3,
 171     ProcessTimes = 4,
 172     ProcessBasePriority = 5,
 173     ProcessRaisePriority = 6,
 174     ProcessDebugPort = 7,
 175     ProcessExceptionPort = 8,
 176     ProcessAccessToken = 9,
 177     ProcessLdtInformation = 10,
 178     ProcessLdtSize = 11,
 179     ProcessDefaultHardErrorMode = 12,
 180     ProcessIoPortHandlers = 13,
 181     ProcessPooledUsageAndLimits = 14,
 182     ProcessWorkingSetWatch = 15,
 183     ProcessUserModeIOPL = 16,
 184     ProcessEnableAlignmentFaultFixup = 17,
 185     ProcessPriorityClass = 18,
 186     ProcessWx86Information = 19,
 187     ProcessHandleCount = 20,
 188     ProcessAffinityMask = 21,
 189     ProcessPriorityBoost = 22,
 190     ProcessDeviceMap = 23,
 191     ProcessSessionInformation = 24,
 192     ProcessForegroundInformation = 25,
 193     ProcessWow64Information = 26,
 194     MaxProcessInfoClass
 195 } PROCESSINFOCLASS;
 196
 197 typedef enum _SECTION_INHERIT {
 198     ViewShare = 1,
 199     ViewUnmap = 2
 200 } SECTION_INHERIT;
 201
 202 typedef enum SYSTEM_INFORMATION_CLASS {
 203     SystemBasicInformation = 0,
 204     Unknown1,
 205     SystemPerformanceInformation = 2,
 206     SystemTimeOfDayInformation = 3, /* was SystemTimeInformation */
 207     Unknown4,
 208     SystemProcessInformation = 5,
 209     Unknown6,
 210     Unknown7,
 211     SystemProcessorPerformanceInformation = 8,
 212     Unknown9,
 213     Unknown10,
 214     SystemDriverInformation,
 215     Unknown12,
 216     Unknown13,
 217     Unknown14,
 218     Unknown15,
 219     SystemHandleList,
 220     Unknown17,
 221     Unknown18,
 222     Unknown19,
 223     Unknown20,
 224     SystemCacheInformation,
 225     Unknown22,
 226     SystemInterruptInformation = 23,
 227     SystemExceptionInformation = 33,
 228     SystemRegistryQuotaInformation = 37,
 229     SystemLookasideInformation = 45
 230 } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
 231
 232 typedef enum _TIMER_TYPE {
 233     NotificationTimer,
 234     SynchronizationTimer
 235 } TIMER_TYPE;
 236
 237 typedef enum _THREADINFOCLASS {
 238     ThreadBasicInformation,
 239     ThreadTimes,
 240     ThreadPriority,
 241     ThreadBasePriority,
 242     ThreadAffinityMask,
 243     ThreadImpersonationToken,
 244     ThreadDescriptorTableEntry,
 245     ThreadEnableAlignmentFaultFixup,
 246     ThreadEventPair_Reusable,
 247     ThreadQuerySetWin32StartAddress,
 248     ThreadZeroTlsCell,
 249     ThreadPerformanceCount,
 250     ThreadAmILastThread,
 251     ThreadIdealProcessor,
 252     ThreadPriorityBoost,
 253     ThreadSetTlsArrayAddress,
 254     ThreadIsIoPending,
 255     MaxThreadInfoClass
 256 } THREADINFOCLASS;
 257
 258 typedef enum _WINSTATIONINFOCLASS {
 259     WinStationInformation = 8
 260 } WINSTATIONINFOCLASS;
 261
 262 typedef enum
 263 {
 264     MemoryBasicInformation = 0
 265 } MEMORY_INFORMATION_CLASS;
 266
 267 /***********************************************************************
 268  * IA64 specific types and data structures
 269  */
 270
 271 #ifdef __ia64__
 272
 273 typedef struct _FRAME_POINTERS {
 274   ULONGLONG MemoryStackFp;
 275   ULONGLONG BackingStoreFp;
 276 } FRAME_POINTERS, *PFRAME_POINTERS;
 277
 278 #define UNWIND_HISTORY_TABLE_SIZE 12
 279
 280 typedef struct _RUNTIME_FUNCTION {
 281   ULONG BeginAddress;
 282   ULONG EndAddress;
 283   ULONG UnwindInfoAddress;
 284 } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION;
 285
 286 typedef struct _UNWIND_HISTORY_TABLE_ENTRY {
 287   ULONG64 ImageBase;
 288   ULONG64 Gp;
 289   PRUNTIME_FUNCTION FunctionEntry;
 290 } UNWIND_HISTORY_TABLE_ENTRY, *PUNWIND_HISTORY_TABLE_ENTRY;
 291
 292 typedef struct _UNWIND_HISTORY_TABLE {
 293   ULONG Count;
 294   UCHAR Search;
 295   ULONG64 LowAddress;
 296   ULONG64 HighAddress;
 297   UNWIND_HISTORY_TABLE_ENTRY Entry[UNWIND_HISTORY_TABLE_SIZE];
 298 } UNWIND_HISTORY_TABLE, *PUNWIND_HISTORY_TABLE;
 299
 300 #endif /* defined(__ia64__) */
 301
 302 /***********************************************************************
 303  * Types and data structures
 304  */
 305
 306 /* This is used by NtQuerySystemInformation */
 307 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 308 typedef struct {
 309     FILETIME ftCreationTime;
 310     DWORD dwUnknown1;
 311     DWORD dwStartAddress;
 312     DWORD dwOwningPID;
 313     DWORD dwThreadID;
 314     DWORD dwCurrentPriority;
 315     DWORD dwBasePriority;
 316     DWORD dwContextSwitches;
 317     DWORD dwThreadState;
 318     DWORD dwWaitReason;
 319     DWORD dwUnknown2[5];
 320 } THREADINFO, *PTHREADINFO;
 321
 322 /* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */
 323 typedef struct _THREAD_INFO{
 324     DWORD Unknown1[6];
 325     DWORD ThreadID;
 326     DWORD Unknown2[3];
 327     DWORD Status;
 328     DWORD WaitReason;
 329     DWORD Unknown3[4];
 330 } THREAD_INFO, PTHREAD_INFO;
 331
 332 /***********************************************************************
 333  * Types and data structures
 334  */
 335
 336 typedef struct _IO_STATUS_BLOCK {
 337   union {
 338     NTSTATUS Status;
 339     PVOID Pointer;
 340   } DUMMYUNIONNAME;
 341
 342   ULONG_PTR Information;
 343 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
 344
 345 typedef void (WINAPI * PIO_APC_ROUTINE)(PVOID,PIO_STATUS_BLOCK,ULONG);
 346
 347 typedef struct _KEY_BASIC_INFORMATION {
 348     LARGE_INTEGER LastWriteTime;
 349     ULONG         TitleIndex;
 350     ULONG         NameLength;
 351     WCHAR         Name[1];
 352 } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
 353
 354 typedef struct _KEY_NODE_INFORMATION
 355 {
 356     LARGE_INTEGER LastWriteTime;
 357     ULONG         TitleIndex;
 358     ULONG         ClassOffset;
 359     ULONG         ClassLength;
 360     ULONG         NameLength;
 361     WCHAR         Name[1];
 362    /* Class[1]; */
 363 } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
 364
 365 typedef struct _KEY_FULL_INFORMATION
 366 {
 367     LARGE_INTEGER LastWriteTime;
 368     ULONG         TitleIndex;
 369     ULONG         ClassOffset;
 370     ULONG         ClassLength;
 371     ULONG         SubKeys;
 372     ULONG         MaxNameLen;
 373     ULONG         MaxClassLen;
 374     ULONG         Values;
 375     ULONG         MaxValueNameLen;
 376     ULONG         MaxValueDataLen;
 377     WCHAR         Class[1];
 378 } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
 379
 380 typedef struct _KEY_VALUE_ENTRY
 381 {
 382     PUNICODE_STRING ValueName;
 383     ULONG           DataLength;
 384     ULONG           DataOffset;
 385     ULONG           Type;
 386 } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
 387
 388 typedef struct _KEY_VALUE_BASIC_INFORMATION {
 389     ULONG TitleIndex;
 390     ULONG Type;
 391     ULONG NameLength;
 392     WCHAR Name[1];
 393 } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
 394
 395 typedef struct _KEY_VALUE_FULL_INFORMATION {
 396     ULONG TitleIndex;
 397     ULONG Type;
 398     ULONG DataOffset;
 399     ULONG DataLength;
 400     ULONG NameLength;
 401     WCHAR Name[1];
 402 } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
 403
 404 typedef struct _KEY_VALUE_PARTIAL_INFORMATION {
 405     ULONG TitleIndex;
 406     ULONG Type;
 407     ULONG DataLength;
 408     UCHAR Data[1];
 409 } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
 410
 411 typedef struct _OBJECT_ATTRIBUTES {
 412   ULONG Length;
 413   HANDLE RootDirectory;
 414   PUNICODE_STRING ObjectName;
 415   ULONG Attributes;
 416   PVOID SecurityDescriptor;       /* type SECURITY_DESCRIPTOR */
 417   PVOID SecurityQualityOfService; /* type SECURITY_QUALITY_OF_SERVICE */
 418 } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
 419
 420 typedef struct _PROCESS_BASIC_INFORMATION {
 421 #ifdef __WINE__
 422     DWORD ExitStatus;
 423     DWORD PebBaseAddress;
 424     DWORD AffinityMask;
 425     DWORD BasePriority;
 426     ULONG UniqueProcessId;
 427     ULONG InheritedFromUniqueProcessId;
 428 #else
 429     PVOID Reserved1;
 430     PPEB PebBaseAddress;
 431     PVOID Reserved2[2];
 432     ULONG_PTR UniqueProcessId;
 433     PVOID Reserved3;
 434 #endif
 435 } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
 436
 437 typedef struct _PROCESS_INFO {
 438     DWORD    Offset;             /* 00 offset to next PROCESS_INFO ok*/
 439     DWORD    ThreadCount;        /* 04 number of ThreadInfo member ok */
 440     DWORD    Unknown1[6];
 441     FILETIME CreationTime;       /* 20 */
 442     DWORD    Unknown2[5];
 443     PWCHAR   ProcessName;        /* 3c ok */
 444     DWORD    BasePriority;
 445     DWORD    ProcessID;          /* 44 ok*/
 446     DWORD    ParentProcessID;
 447     DWORD    HandleCount;
 448     DWORD    Unknown3[2];        /* 50 */
 449     ULONG    PeakVirtualSize;
 450     ULONG    VirtualSize;
 451     ULONG    PageFaultCount;
 452     ULONG    PeakWorkingSetSize;
 453     ULONG    WorkingSetSize;
 454     ULONG    QuotaPeakPagedPoolUsage;
 455     ULONG    QuotaPagedPoolUsage;
 456     ULONG    QuotaPeakNonPagedPoolUsage;
 457     ULONG    QuotaNonPagedPoolUsage;
 458     ULONG    PagefileUsage;
 459     ULONG    PeakPagefileUsage;
 460     DWORD    PrivateBytes;
 461     DWORD    Unknown6[4];
 462     THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/
 463 } PROCESS_INFO, PPROCESS_INFO;
 464
 465 typedef struct _RTL_HEAP_DEFINITION {
 466     ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
 467
 468     ULONG Unknown[11];
 469 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 470
 471 typedef struct tagRTL_BITMAP {
 472     ULONG  SizeOfBitMap; /* Number of bits in the bitmap */
 473     LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */
 474 } RTL_BITMAP, *PRTL_BITMAP;
 475
 476 typedef const RTL_BITMAP *PCRTL_BITMAP;
 477
 478 typedef struct tagRTL_BITMAP_RUN {
 479     ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */
 480     ULONG SizeOfRun;  /* Size of the run in bits - FIXME: Name? */
 481 } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
 482
 483 typedef const RTL_BITMAP_RUN *PCRTL_BITMAP_RUN;
 484
 485 typedef struct _RTL_RWLOCK {
 486     RTL_CRITICAL_SECTION rtlCS;
 487
 488     HANDLE hSharedReleaseSemaphore;
 489     UINT   uSharedWaiters;
 490
 491     HANDLE hExclusiveReleaseSemaphore;
 492     UINT   uExclusiveWaiters;
 493
 494     INT    iNumberActive;
 495     HANDLE hOwningThreadId;
 496     DWORD  dwTimeoutBoost;
 497     PVOID  pDebugInfo;
 498 } RTL_RWLOCK, *LPRTL_RWLOCK;
 499
 500 /* System Information Class 0x00 */
 501 typedef struct _SYSTEM_BASIC_INFORMATION {
 502 #ifdef __WINE__
 503     DWORD dwUnknown1;
 504     ULONG uKeMaximumIncrement;
 505     ULONG uPageSize;
 506     ULONG uMmNumberOfPhysicalPages;
 507     ULONG uMmLowestPhysicalPage;
 508     ULONG uMmHighestPhysicalPage;
 509     ULONG uAllocationGranularity;
 510     PVOID pLowestUserAddress;
 511     PVOID pMmHighestUserAddress;
 512     ULONG uKeActiveProcessors;
 513     BYTE bKeNumberProcessors;
 514     BYTE bUnknown2;
 515     WORD wUnknown3;
 516 #else
 517     BYTE Reserved1[24];
 518     PVOID Reserved2[4];
 519     CCHAR NumberOfProcessors;
 520 #endif
 521 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 522
 523 /* System Information Class 0x15 */
 524 typedef struct {
 525     ULONG CurrentSize;
 526     ULONG PeakSize;
 527     ULONG PageFaultCount;
 528     ULONG MinimumWorkingSet;
 529     ULONG MaximumWorkingSet;
 530     ULONG unused[4];
 531 } SYSTEM_CACHE_INFORMATION;
 532
 533 typedef struct _SYSTEM_CONFIGURATION_INFO {
 534     union {
 535         ULONG   OemId;
 536         struct {
 537             WORD ProcessorArchitecture;
 538             WORD Reserved;
 539         } tag1;
 540     } tag2;
 541     ULONG PageSize;
 542     PVOID MinimumApplicationAddress;
 543     PVOID MaximumApplicationAddress;
 544     ULONG ActiveProcessorMask;
 545     ULONG NumberOfProcessors;
 546     ULONG ProcessorType;
 547     ULONG AllocationGranularity;
 548     WORD  ProcessorLevel;
 549     WORD  ProcessorRevision;
 550 } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
 551
 552 /* System Information Class 0x0b */
 553 typedef struct {
 554     PVOID pvAddress;
 555     DWORD dwUnknown1;
 556     DWORD dwUnknown2;
 557     DWORD dwEntryIndex;
 558     DWORD dwUnknown3;
 559     char szName[MAX_PATH + 1];
 560 } SYSTEM_DRIVER_INFORMATION;
 561
 562 typedef struct _SYSTEM_EXCEPTION_INFORMATION {
 563     BYTE Reserved1[16];
 564 } SYSTEM_EXCEPTION_INFORMATION, *PSYSTEM_EXCEPTION_INFORMATION;
 565
 566 typedef struct _SYSTEM_LOOKASIDE_INFORMATION {
 567     BYTE Reserved1[32];
 568 } SYSTEM_LOOKASIDE_INFORMATION, *PSYSTEM_LOOKASIDE_INFORMATION;
 569
 570 typedef struct _SYSTEM_INTERRUPT_INFORMATION {
 571     BYTE Reserved1[24];
 572 } SYSTEM_INTERRUPT_INFORMATION, *PSYSTEM_INTERRUPT_INFORMATION;
 573
 574 /* System Information Class 0x10 */
 575 typedef struct {
 576     USHORT dwPID;
 577     USHORT dwCreatorBackTraceIndex;
 578     BYTE bObjectType;
 579     BYTE bHandleAttributes;
 580     USHORT usHandleOffset;
 581     DWORD dwKeObject;
 582     ULONG ulGrantedAccess;
 583 } HANDLEINFO, *PHANDLEINFO; /* FIXME: SYSTEM_HANDLE_INFORMATION? */
 584
 585 typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
 586     BYTE Reserved1[312];
 587 } SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
 588
 589 /* System Information Class 0x02 */
 590 typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
 591 #ifdef __WINE__
 592     LARGE_INTEGER liIdleTime;
 593     DWORD dwSpare[76];
 594 #else
 595     LARGE_INTEGER IdleTime;
 596     LARGE_INTEGER KernelTime;
 597     LARGE_INTEGER UserTime;
 598     LARGE_INTEGER Reserved1[2];
 599     ULONG Reserved2;
 600 #endif
 601 } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
 602
 603 /* System Information Class 0x05 */
 604 typedef struct _SYSTEM_PROCESS_INFORMATION {
 605 #ifdef __WINE__
 606     DWORD dwOffset;
 607     DWORD dwThreadCount;
 608     DWORD dwUnknown1[6];
 609     FILETIME ftCreationTime;
 610     DWORD dwUnknown2[5];
 611     WCHAR *pszProcessName;
 612     DWORD dwBasePriority;
 613     DWORD dwProcessID;
 614     DWORD dwParentProcessID;
 615     DWORD dwHandleCount;
 616     DWORD dwUnknown3;
 617     DWORD dwUnknown4;
 618     DWORD dwVirtualBytesPeak;
 619     DWORD dwVirtualBytes;
 620     DWORD dwPageFaults;
 621     DWORD dwWorkingSetPeak;
 622     DWORD dwWorkingSet;
 623     DWORD dwUnknown5;
 624     DWORD dwPagedPool;
 625     DWORD dwUnknown6;
 626     DWORD dwNonPagedPool;
 627     DWORD dwPageFileBytesPeak;
 628     DWORD dwPrivateBytes;
 629     DWORD dwPageFileBytes;
 630     DWORD dwUnknown7[4];
 631     THREADINFO ti[1];
 632 #else
 633     ULONG NextEntryOffset;
 634     BYTE Reserved1[52];
 635     PVOID Reserved2[3];
 636     HANDLE UniqueProcessId;
 637     PVOID Reserved3;
 638     ULONG HandleCount;
 639     BYTE Reserved4[4];
 640     PVOID Reserved5[11];
 641     SIZE_T PeakPagefileUsage;
 642     SIZE_T PrivatePageCount;
 643     LARGE_INTEGER Reserved6[6];
 644 #endif
 645 } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
 646
 647 typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {
 648     ULONG RegistryQuotaAllowed;
 649     ULONG RegistryQuotaUsed;
 650     PVOID Reserved1;
 651 } SYSTEM_REGISTRY_QUOTA_INFORMATION, *PSYSTEM_REGISTRY_QUOTA_INFORMATION;
 652
 653 typedef struct _SYSTEM_TIME_ADJUSTMENT {
 654     ULONG   TimeAdjustment;
 655     BOOLEAN TimeAdjustmentDisabled;
 656 } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
 657
 658 /* System Information Class 0x03 */
 659 typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {
 660 #ifdef __WINE__
 661     LARGE_INTEGER liKeBootTime;
 662     LARGE_INTEGER liKeSystemTime;
 663     LARGE_INTEGER liExpTimeZoneBias;
 664     ULONG uCurrentTimeZoneId;
 665     DWORD dwReserved;
 666 #else
 667     BYTE Reserved1[48];
 668 #endif
 669 } SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; /* was SYSTEM_TIME_INFORMATION */
 670
 671 typedef struct _TIME_FIELDS
 672 {   CSHORT Year;
 673     CSHORT Month;
 674     CSHORT Day;
 675     CSHORT Hour;
 676     CSHORT Minute;
 677     CSHORT Second;
 678     CSHORT Milliseconds;
 679     CSHORT Weekday;
 680 } TIME_FIELDS, *PTIME_FIELDS;
 681
 682 typedef struct _WINSTATIONINFORMATIONW {
 683   BYTE Reserved2[70];
 684   ULONG LogonId;
 685   BYTE Reserved3[1140];
 686 } WINSTATIONINFORMATIONW, *PWINSTATIONINFORMATIONW;
 687
 688 typedef struct _VM_COUNTERS_ {
 689     ULONG PeakVirtualSize;
 690     ULONG VirtualSize;
 691     ULONG PageFaultCount;
 692     ULONG PeakWorkingSetSize;
 693     ULONG WorkingSetSize;
 694     ULONG QuotaPeakPagedPoolUsage;
 695     ULONG QuotaPagedPoolUsage;
 696     ULONG QuotaPeakNonPagedPoolUsage;
 697     ULONG QuotaNonPagedPoolUsage;
 698     ULONG PagefileUsage;
 699     ULONG PeakPagefileUsage;
 700 } VM_COUNTERS, *PVM_COUNTERS;
 701
 702 typedef BOOLEAN (WINAPI * PWINSTATIONQUERYINFORMATIONW)(HANDLE,ULONG,WINSTATIONINFOCLASS,PVOID,ULONG,PULONG);
 703
 704 /***********************************************************************
 705  * Defines
 706  */
 707
 708 /* flags for NtCreateFile and NtOpenFile */
 709 #define FILE_DIRECTORY_FLAG  0x00000001
 710 #define FILE_WRITE_THROUGH   0x00000002
 711 #define FILE_SEQUENTIAL_ONLY 0x00000004
 712 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
 713 #define FILE_SYNCHRONOUS_IO_ALERT    0x00000010
 714 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
 715 #define FILE_NON_DIRECTORY_FILE      0x00000040
 716 #define FILE_CREATE_TREE_CONNECTION  0x00000080
 717
 718 /* status for NtCreateFile or NtOpenFile */
 719 #define FILE_SUPERSEDED  0x00000000
 720 #define FILE_OPENED      0x00000001
 721 #define FILE_CREATED     0x00000002
 722 #define FILE_OVERWRITTEN 0x00000003
 723 #define FILE_EXISTS      0x00000004
 724 #define FILE_DOES_NOT_EXIST 0x00000005
 725
 726 #if (_WIN32_WINNT >= 0x0501)
 727 #define INTERNAL_TS_ACTIVE_CONSOLE_ID ( *((volatile ULONG*)(0x7ffe02d8)) )
 728 #endif /* (_WIN32_WINNT >= 0x0501) */
 729
 730 #define LOGONID_CURRENT    ((ULONG)-1)
 731
 732 #define OBJ_INHERIT          0x00000002L
 733 #define OBJ_PERMANENT        0x00000010L
 734 #define OBJ_EXCLUSIVE        0x00000020L
 735 #define OBJ_CASE_INSENSITIVE 0x00000040L
 736 #define OBJ_OPENIF           0x00000080L
 737 #define OBJ_OPENLINK         0x00000100L
 738 #define OBJ_KERNEL_HANDLE    0x00000200L
 739 #define OBJ_VALID_ATTRIBUTES 0x000003F2L
 740
 741 #define SERVERNAME_CURRENT ((HANDLE)NULL)
 742
 743 /***********************************************************************
 744  * Function declarations
 745  */
 746
 747 extern LPSTR _strlwr(LPSTR str); /* FIXME: Doesn't belong here */
 748 extern LPSTR _strupr(LPSTR str); /* FIXME: Doesn't belong here */
 749
 750 #if defined(__i386__) && defined(__GNUC__)
 751 static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
 752 static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
 753 #else  /* __i386__ && __GNUC__ */
 754 void WINAPI DbgBreakPoint(void);
 755 void WINAPI DbgUserBreakPoint(void);
 756 #endif  /* __i386__ && __GNUC__ */
 757 void WINAPIV DbgPrint(LPCSTR fmt, ...);
 758
 759 NTSTATUS  WINAPI NtAccessCheck(PSECURITY_DESCRIPTOR,HANDLE,ACCESS_MASK,PGENERIC_MAPPING,PPRIVILEGE_SET,PULONG,PULONG,PBOOLEAN);
 760 NTSTATUS  WINAPI NtAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
 761 NTSTATUS  WINAPI NtAllocateVirtualMemory(HANDLE,PVOID*,PVOID,ULONG*,ULONG,ULONG);
 762 NTSTATUS  WINAPI NtClearEvent(HANDLE);
 763 NTSTATUS  WINAPI NtClose(HANDLE);
 764 NTSTATUS  WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
 765 NTSTATUS  WINAPI NtCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
 766 NTSTATUS  WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
 767 NTSTATUS  WINAPI NtCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
 768 NTSTATUS  WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
 769 NTSTATUS  WINAPI NtDeleteKey(HANDLE);
 770 NTSTATUS  WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING *);
 771 NTSTATUS  WINAPI NtDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
 772 NTSTATUS  WINAPI NtDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
 773 NTSTATUS  WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 774 NTSTATUS  WINAPI NtEnumerateValueKey(HANDLE,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 775 NTSTATUS  WINAPI NtFlushKey(HANDLE);
 776 NTSTATUS  WINAPI NtFlushVirtualMemory(HANDLE,LPCVOID*,ULONG*,ULONG);
 777 NTSTATUS  WINAPI NtFreeVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 778 NTSTATUS  WINAPI NtLoadKey(const OBJECT_ATTRIBUTES *,const OBJECT_ATTRIBUTES *);
 779 NTSTATUS  WINAPI NtLockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 780 NTSTATUS  WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,ULONG,const LARGE_INTEGER*,ULONG*,SECTION_INHERIT,ULONG,ULONG);
 781 NTSTATUS  WINAPI NtNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
 782 NTSTATUS  WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 783 NTSTATUS  WINAPI NtOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
 784 NTSTATUS  WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
 785 NTSTATUS  WINAPI NtOpenProcessToken(HANDLE,DWORD,HANDLE *);
 786 NTSTATUS  WINAPI NtOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 787 NTSTATUS  WINAPI NtOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
 788 NTSTATUS  WINAPI NtProtectVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG,ULONG*);
 789 NTSTATUS  WINAPI NtPulseEvent(HANDLE,PULONG);
 790 NTSTATUS  WINAPI NtQueryInformationProcess(HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);
 791 NTSTATUS  WINAPI NtQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
 792 NTSTATUS  WINAPI NtQueryInformationToken(HANDLE,DWORD,LPVOID,DWORD,LPDWORD);
 793 NTSTATUS  WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
 794 NTSTATUS  WINAPI NtQueryMultipleValueKey(HANDLE,PVALENTW,ULONG,PVOID,ULONG,PULONG);
 795 NTSTATUS  WINAPI NtQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
 796 NTSTATUS  WINAPI NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 797 NTSTATUS  WINAPI NtQuerySystemTime(PLARGE_INTEGER);
 798 NTSTATUS  WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
 799 NTSTATUS  WINAPI NtQueryVirtualMemory(HANDLE,LPCVOID,MEMORY_INFORMATION_CLASS,PVOID,ULONG,ULONG*);
 800 void      WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
 801 NTSTATUS  WINAPI NtReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
 802 NTSTATUS  WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
 803 NTSTATUS  WINAPI NtResetEvent(HANDLE,PULONG);
 804 NTSTATUS  WINAPI NtRestoreKey(HANDLE,HANDLE,ULONG);
 805 NTSTATUS  WINAPI NtReplaceKey(POBJECT_ATTRIBUTES,HANDLE,POBJECT_ATTRIBUTES);
 806 NTSTATUS  WINAPI NtSaveKey(HANDLE,HANDLE);
 807 NTSTATUS  WINAPI NtSetEvent(HANDLE,PULONG);
 808 NTSTATUS  WINAPI NtSetInformationKey(HANDLE,const int,PVOID,ULONG);
 809 NTSTATUS  WINAPI NtSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
 810 NTSTATUS  WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
 811 NTSTATUS  WINAPI NtTerminateProcess(HANDLE,LONG);
 812 NTSTATUS  WINAPI NtTerminateThread(HANDLE,LONG);
 813 NTSTATUS  WINAPI NtUnloadKey(HANDLE);
 814 NTSTATUS  WINAPI NtUnlockVirtualMemory(HANDLE,PVOID*,ULONG*,ULONG);
 815 NTSTATUS  WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
 816 NTSTATUS  WINAPI NtWaitForSingleObject(HANDLE,BOOLEAN,PLARGE_INTEGER);
 817
 818 void      WINAPI RtlAcquirePebLock(void);
 819 BYTE      WINAPI RtlAcquireResourceExclusive(LPRTL_RWLOCK,BYTE);
 820 BYTE      WINAPI RtlAcquireResourceShared(LPRTL_RWLOCK,BYTE);
 821 NTSTATUS  WINAPI RtlAddAce(PACL,DWORD,DWORD,PACE_HEADER,DWORD);
 822 BOOL      WINAPI RtlAddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
 823 BOOL      WINAPI RtlAddAccessAllowedAceEx(PACL,DWORD,DWORD,DWORD,PSID);
 824 DWORD     WINAPI RtlAdjustPrivilege(DWORD,DWORD,DWORD,DWORD);
 825 BOOLEAN   WINAPI RtlAllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,PSID *);
 826 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
 827 DWORD     WINAPI RtlAnsiStringToUnicodeSize(const STRING *);
 828 NTSTATUS  WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING,PCANSI_STRING,BOOLEAN);
 829 NTSTATUS  WINAPI RtlAppendAsciizToString(STRING *,LPCSTR);
 830 NTSTATUS  WINAPI RtlAppendStringToString(STRING *,const STRING *);
 831 NTSTATUS  WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING *,const UNICODE_STRING *);
 832 NTSTATUS  WINAPI RtlAppendUnicodeToString(UNICODE_STRING *,LPCWSTR);
 833 BOOLEAN   WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
 834 BOOLEAN   WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
 835
 836 NTSTATUS  WINAPI RtlCharToInteger(PCSZ,ULONG,PULONG);
 837 void      WINAPI RtlClearAllBits(PRTL_BITMAP);
 838 void      WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
 839 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
 840 LONG      WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
 841 LONG      WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 842 NTSTATUS  WINAPI RtlConvertSidToUnicodeString(PUNICODE_STRING,PSID,BOOLEAN);
 843 LONGLONG  WINAPI RtlConvertLongToLargeInteger(LONG);
 844 ULONGLONG WINAPI RtlConvertUlongToLargeInteger(ULONG);
 845 DWORD     WINAPI RtlCopySid(DWORD,PSID,PSID);
 846 void      WINAPI RtlCopyString(STRING*,const STRING*);
 847 void      WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
 848 NTSTATUS  WINAPI RtlCreateAcl(PACL,DWORD,DWORD);
 849 DWORD     WINAPI RtlCreateEnvironment(DWORD,DWORD);
 850 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
 851 NTSTATUS  WINAPI RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR,DWORD);
 852 BOOLEAN   WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
 853 BOOLEAN   WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
 854
 855 NTSTATUS  WINAPI RtlDeleteCriticalSection(RTL_CRITICAL_SECTION *);
 856 void      WINAPI RtlDeleteResource(LPRTL_RWLOCK);
 857 DWORD     WINAPI RtlDeleteSecurityObject(DWORD);
 858 DWORD     WINAPI RtlDestroyEnvironment(DWORD);
 859 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
 860 BOOLEAN   WINAPI RtlDosPathNameToNtPathName_U(LPWSTR,PUNICODE_STRING,DWORD,DWORD);
 861 void      WINAPI RtlDumpResource(LPRTL_RWLOCK);
 862
 863 LONGLONG  WINAPI RtlEnlargedIntegerMultiply(INT,INT);
 864 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply(UINT,UINT);
 865 UINT      WINAPI RtlEnlargedUnsignedDivide(ULONGLONG,UINT,UINT *);
 866 NTSTATUS  WINAPI RtlEnterCriticalSection(RTL_CRITICAL_SECTION *);
 867 void      WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
 868 BOOL      WINAPI RtlEqualPrefixSid(PSID,PSID);
 869 BOOL      WINAPI RtlEqualSid(PSID,PSID);
 870 BOOLEAN   WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
 871 BOOLEAN   WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 872 LONGLONG  WINAPI RtlExtendedMagicDivide(LONGLONG,LONGLONG,INT);
 873 LONGLONG  WINAPI RtlExtendedIntegerMultiply(LONGLONG,INT);
 874 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide(LONGLONG,INT,INT *);
 875
 876 ULONG     WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
 877 ULONG     WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
 878 ULONG     WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
 879 ULONG     WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
 880 ULONG     WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
 881 CCHAR     WINAPI RtlFindLeastSignificantBit(ULONGLONG);
 882 ULONG     WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
 883 ULONG     WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
 884 CCHAR     WINAPI RtlFindMostSignificantBit(ULONGLONG);
 885 ULONG     WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
 886 ULONG     WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
 887 ULONG     WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
 888 ULONG     WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
 889 ULONG     WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
 890 BOOLEAN   WINAPI RtlFirstFreeAce(PACL,PACE_HEADER *);
 891 NTSTATUS  WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING);
 892 void      WINAPI RtlFreeAnsiString(PANSI_STRING);
 893 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
 894 void      WINAPI RtlFreeOemString(POEM_STRING);
 895 DWORD     WINAPI RtlFreeSid(PSID);
 896 void      WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
 897
 898 DWORD     WINAPI RtlGetAce(PACL,DWORD,LPVOID *);
 899 NTSTATUS  WINAPI RtlGetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
 900 NTSTATUS  WINAPI RtlGetControlSecurityDescriptor(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL,LPDWORD);
 901 NTSTATUS  WINAPI RtlGetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
 902 BOOLEAN   WINAPI RtlGetNtProductType(LPDWORD);
 903 NTSTATUS  WINAPI RtlGetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID *,PBOOLEAN);
 904 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
 905 NTSTATUS  WINAPI RtlGetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,PBOOLEAN,PACL *,PBOOLEAN);
 906
 907 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(PSID);
 908 PVOID     WINAPI RtlImageDirectoryEntryToData(HMODULE,BOOL,WORD,ULONG *);
 909 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE);
 910 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection(const IMAGE_NT_HEADERS *,HMODULE,DWORD);
 911 PVOID     WINAPI RtlImageRvaToVa(const IMAGE_NT_HEADERS *,HMODULE,DWORD,IMAGE_SECTION_HEADER **);
 912 BOOL      WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
 913 void      WINAPI RtlInitString(PSTRING,PCSZ);
 914 void      WINAPI RtlInitAnsiString(PANSI_STRING,PCSZ);
 915 void      WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
 916 NTSTATUS  WINAPI RtlInitializeCriticalSection(RTL_CRITICAL_SECTION *);
 917 NTSTATUS  WINAPI RtlInitializeCriticalSectionAndSpinCount(RTL_CRITICAL_SECTION *,DWORD);
 918 void      WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
 919 void      WINAPI RtlInitializeResource(LPRTL_RWLOCK);
 920 BOOL      WINAPI RtlInitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
 921
 922 DWORD     WINAPI RtlIntegerToChar(DWORD,DWORD,DWORD,DWORD);
 923 BOOLEAN   WINAPI RtlIsNameLegalDOS8Dot3(PUNICODE_STRING,POEM_STRING,PBOOLEAN);
 924 DWORD     WINAPI RtlIsTextUnicode(LPVOID,DWORD,DWORD *);
 925
 926 LONGLONG  WINAPI RtlLargeIntegerAdd(LONGLONG,LONGLONG);
 927 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift(LONGLONG,INT);
 928 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG,ULONGLONG,ULONGLONG *);
 929 LONGLONG  WINAPI RtlLargeIntegerNegate(LONGLONG);
 930 LONGLONG  WINAPI RtlLargeIntegerShiftLeft(LONGLONG,INT);
 931 LONGLONG  WINAPI RtlLargeIntegerShiftRight(LONGLONG,INT);
 932 LONGLONG  WINAPI RtlLargeIntegerSubtract(LONGLONG,LONGLONG);
 933 NTSTATUS  WINAPI RtlLeaveCriticalSection(RTL_CRITICAL_SECTION *);
 934 DWORD     WINAPI RtlLengthRequiredSid(DWORD);
 935 ULONG     WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR);
 936 DWORD     WINAPI RtlLengthSid(PSID);
 937 NTSTATUS  WINAPI RtlLocalTimeToSystemTime(PLARGE_INTEGER,PLARGE_INTEGER);
 938 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
 939
 940 NTSTATUS  WINAPI RtlMakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
 941 NTSTATUS  WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
 942 NTSTATUS  WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
 943
 944 DWORD     WINAPI RtlNewSecurityObject(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD);
 945 LPVOID    WINAPI RtlNormalizeProcessParams(LPVOID);
 946 ULONG     WINAPI RtlNtStatusToDosError(NTSTATUS);
 947 ULONG     WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
 948 ULONG     WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
 949
 950 UINT      WINAPI RtlOemStringToUnicodeSize(const STRING*);
 951 NTSTATUS  WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
 952 NTSTATUS  WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
 953 DWORD     WINAPI RtlOpenCurrentUser(ACCESS_MASK,PHANDLE);
 954
 955 BOOLEAN   WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
 956 BOOLEAN   WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 957
 958 DWORD     WINAPI RtlQueryEnvironmentVariable_U(DWORD,PUNICODE_STRING,PUNICODE_STRING) ;
 959
 960 void      WINAPI RtlRaiseException(PEXCEPTION_RECORD);
 961 void      WINAPI RtlRaiseStatus(NTSTATUS);
 962 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
 963 void      WINAPI RtlReleasePebLock(void);
 964 void      WINAPI RtlReleaseResource(LPRTL_RWLOCK);
 965
 966 void      WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
 967 void      WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
 968 void      WINAPI RtlSetAllBits(PRTL_BITMAP);
 969 void      WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
 970 NTSTATUS  WINAPI RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
 971 DWORD     WINAPI RtlSetEnvironmentVariable(DWORD,PUNICODE_STRING,PUNICODE_STRING);
 972 NTSTATUS  WINAPI RtlSetOwnerSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
 973 NTSTATUS  WINAPI RtlSetGroupSecurityDescriptor(PSECURITY_DESCRIPTOR,PSID,BOOLEAN);
 974 NTSTATUS  WINAPI RtlSetSaclSecurityDescriptor(PSECURITY_DESCRIPTOR,BOOLEAN,PACL,BOOLEAN);
 975 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
 976 LPDWORD   WINAPI RtlSubAuthoritySid(PSID,DWORD);
 977 LPBYTE    WINAPI RtlSubAuthorityCountSid(PSID);
 978 void      WINAPI RtlSystemTimeToLocalTime(PLARGE_INTEGER,PLARGE_INTEGER);
 979
 980 void      WINAPI RtlTimeToTimeFields(PLARGE_INTEGER,PTIME_FIELDS);
 981 BOOLEAN   WINAPI RtlTimeFieldsToTime(PTIME_FIELDS,PLARGE_INTEGER);
 982 void      WINAPI RtlTimeToElapsedTimeFields(PLARGE_INTEGER,PTIME_FIELDS);
 983 BOOLEAN   WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,PULONG);
 984 BOOLEAN   WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
 985 BOOL      WINAPI RtlTryEnterCriticalSection(RTL_CRITICAL_SECTION *);
 986
 987 DWORD     WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
 988 NTSTATUS  WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING,PCUNICODE_STRING,BOOLEAN);
 989 DWORD     WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
 990 NTSTATUS  WINAPI RtlUnicodeStringToOemString(POEM_STRING,PCUNICODE_STRING,BOOLEAN);
 991 NTSTATUS  WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 992 NTSTATUS  WINAPI RtlUnicodeToMultiByteSize(PULONG,PCWSTR,ULONG);
 993 NTSTATUS  WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 994 ULONG     WINAPI RtlUniform(PULONG);
 995 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
 996 void      WINAPI RtlUnwind(PVOID,PVOID,PEXCEPTION_RECORD,PVOID);
 997 #ifdef __ia64__
 998 void      WINAPI RtlUnwind2(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT);
 999 void      WINAPI RtlUnwindEx(FRAME_POINTERS,PVOID,PEXCEPTION_RECORD,PVOID,PCONTEXT,PUNWIND_HISTORY_TABLE);
1000 #endif
1001 NTSTATUS  WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
1002 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
1003 NTSTATUS  WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
1004 NTSTATUS  WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1005 NTSTATUS  WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
1006
1007 NTSTATUS  WINAPI RtlValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1008 BOOL      WINAPI RtlValidSid(PSID);
1009 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,LPCVOID);
1010
1011 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
1012
1013 NTSTATUS  WINAPI RtlpWaitForCriticalSection(RTL_CRITICAL_SECTION *);
1014 NTSTATUS  WINAPI RtlpUnWaitCriticalSection(RTL_CRITICAL_SECTION *);
1015
1016 /***********************************************************************
1017  * Inline functions
1018  */
1019
1020 #define InitializeObjectAttributes(p,n,a,r,s) \
1021     do { \
1022         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
1023         (p)->RootDirectory = r; \
1024         (p)->Attributes = a; \
1025         (p)->ObjectName = n; \
1026         (p)->SecurityDescriptor = s; \
1027         (p)->SecurityQualityOfService = NULL; \
1028     } while (0)
1029
1030 #define NtCurrentProcess() ((HANDLE)-1)
1031
1032 #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
1033 #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
1034 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1035 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1036 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1037 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1038 #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
1039
1040 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1041 {
1042     if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1043         lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1044         return TRUE;
1045     return FALSE;
1046 }
1047
1048 #define RtlClearAllBits(p) \
1049     do { \
1050         PRTL_BITMAP _p = (p); \
1051         memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1052     } while (0)
1053
1054 #define RtlInitializeBitMap(p,b,s) \
1055     do { \
1056         PRTL_BITMAP _p = (p); \
1057         _p->SizeOfBitMap = (s); \
1058         _p->BitMapBuffer = (b); \
1059     } while (0)
1060
1061 #define RtlSetAllBits(p) \
1062     do { \
1063         PRTL_BITMAP _p = (p); \
1064         memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1065     } while (0)
1066
1067 #ifdef __cplusplus
1068 } /* extern "C" */
1069 #endif /* defined(__cplusplus) */
1070
1071 #endif  /* __WINE_WINTERNAL_H */