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

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