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