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