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

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