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