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

   1 /*
   2         this file defines interfaces mainly exposed to device drivers and
   3         native nt dll's
   4
   5 */
   6 #ifndef __WINE_NTDDK_H
   7 #define __WINE_NTDDK_H
   8
   9 #include "ntdef.h"
  10 #include "winnt.h"
  11 #include "winreg.h"
  12 #include "winbase.h"    /* fixme: should be taken out sometimes */
  13
  14 #include "pshpack1.h"
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 /******************
  21  * asynchronous I/O
  22  */
  23 #undef Status   /* conflict with X11-includes*/
  24
  25 typedef struct _IO_STATUS_BLOCK
  26 {
  27         union {
  28           NTSTATUS Status;
  29           PVOID Pointer;
  30         } DUMMYUNIONNAME;
  31         ULONG_PTR Information;
  32 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
  33
  34 typedef VOID NTAPI (*PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
  35
  36 /*
  37         registry
  38  */
  39
  40  /* key information */
  41 typedef struct _KEY_BASIC_INFORMATION {
  42         FILETIME        LastWriteTime;
  43         ULONG           TitleIndex;
  44         ULONG           NameLength;
  45         WCHAR           Name[1];
  46 } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
  47
  48 typedef struct _KEY_NODE_INFORMATION
  49 {
  50         FILETIME        LastWriteTime;
  51         ULONG           TitleIndex;
  52         ULONG           ClassOffset;
  53         ULONG           ClassLength;
  54         ULONG           NameLength;
  55         WCHAR           Name[1];
  56 /*      Class[1]; */
  57 } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
  58
  59 typedef struct _KEY_FULL_INFORMATION
  60 {
  61         FILETIME        LastWriteTime;
  62         ULONG           TitleIndex;
  63         ULONG           ClassOffset;
  64         ULONG           ClassLength;
  65         ULONG           SubKeys;
  66         ULONG           MaxNameLen;
  67         ULONG           MaxClassLen;
  68         ULONG           Values;
  69         ULONG           MaxValueNameLen;
  70         ULONG           MaxValueDataLen;
  71         WCHAR           Class[1];
  72 } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
  73
  74 typedef enum _KEY_INFORMATION_CLASS
  75 {
  76         KeyBasicInformation,
  77         KeyNodeInformation,
  78         KeyFullInformation
  79 } KEY_INFORMATION_CLASS;
  80
  81 typedef struct _KEY_VALUE_ENTRY
  82 {
  83         PUNICODE_STRING ValueName;
  84         ULONG           DataLength;
  85         ULONG           DataOffset;
  86         ULONG           Type;
  87 } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
  88
  89 /* value information */
  90 typedef struct _KEY_VALUE_BASIC_INFORMATION
  91 {
  92         ULONG   TitleIndex;
  93         ULONG   Type;
  94         ULONG   NameLength;
  95         WCHAR   Name[1];
  96 } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
  97
  98 typedef struct _KEY_VALUE_FULL_INFORMATION
  99 {
 100         ULONG   TitleIndex;
 101         ULONG   Type;
 102         ULONG   DataOffset;
 103         ULONG   DataLength;
 104         ULONG   NameLength;
 105         WCHAR   Name[1];
 106 /*      UCHAR   Data[1];*/
 107 } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
 108
 109 typedef struct _KEY_VALUE_PARTIAL_INFORMATION
 110 {
 111         ULONG   TitleIndex;
 112         ULONG   Type;
 113         ULONG   DataLength;
 114         UCHAR   Data[1];
 115 } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
 116
 117 typedef enum _KEY_VALUE_INFORMATION_CLASS
 118 {
 119         KeyValueBasicInformation,
 120         KeyValueFullInformation,
 121         KeyValuePartialInformation,
 122         KeyValueFullInformationAlign64,
 123         KeyValuePartialInformationAlign64
 124 } KEY_VALUE_INFORMATION_CLASS;
 125
 126 NTSTATUS WINAPI RtlFormatCurrentUserKeyPath(
 127         PUNICODE_STRING KeyPath);
 128
 129 /*      thread information */
 130
 131 typedef enum _THREADINFOCLASS
 132 {       ThreadBasicInformation,
 133         ThreadTimes,
 134         ThreadPriority,
 135         ThreadBasePriority,
 136         ThreadAffinityMask,
 137         ThreadImpersonationToken,
 138         ThreadDescriptorTableEntry,
 139         ThreadEnableAlignmentFaultFixup,
 140         ThreadEventPair_Reusable,
 141         ThreadQuerySetWin32StartAddress,
 142         ThreadZeroTlsCell,
 143         ThreadPerformanceCount,
 144         ThreadAmILastThread,
 145         ThreadIdealProcessor,
 146         ThreadPriorityBoost,
 147         ThreadSetTlsArrayAddress,
 148         ThreadIsIoPending,
 149         MaxThreadInfoClass
 150 } THREADINFOCLASS;
 151
 152 /*      file information */
 153
 154 typedef enum _FILE_INFORMATION_CLASS {
 155         FileDirectoryInformation = 1,
 156         FileFullDirectoryInformation,
 157         FileBothDirectoryInformation,
 158         FileBasicInformation,
 159         FileStandardInformation,
 160         FileInternalInformation,
 161         FileEaInformation,
 162         FileAccessInformation,
 163         FileNameInformation,
 164         FileRenameInformation,
 165         FileLinkInformation,
 166         FileNamesInformation,
 167         FileDispositionInformation,
 168         FilePositionInformation,
 169         FileFullEaInformation,
 170         FileModeInformation,
 171         FileAlignmentInformation,
 172         FileAllInformation,
 173         FileAllocationInformation,
 174         FileEndOfFileInformation,
 175         FileAlternateNameInformation,
 176         FileStreamInformation,
 177         FilePipeInformation,
 178         FilePipeLocalInformation,
 179         FilePipeRemoteInformation,
 180         FileMailslotQueryInformation,
 181         FileMailslotSetInformation,
 182         FileCompressionInformation,
 183         FileObjectIdInformation,
 184         FileCompletionInformation,
 185         FileMoveClusterInformation,
 186         FileQuotaInformation,
 187         FileReparsePointInformation,
 188         FileNetworkOpenInformation,
 189         FileAttributeTagInformation,
 190         FileTrackingInformation,
 191         FileMaximumInformation
 192 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
 193
 194 typedef enum _FSINFOCLASS {
 195         FileFsVolumeInformation = 1,
 196         FileFsLabelInformation,
 197         FileFsSizeInformation,
 198         FileFsDeviceInformation,
 199         FileFsAttributeInformation,
 200         FileFsControlInformation,
 201         FileFsFullSizeInformation,
 202         FileFsObjectIdInformation,
 203         FileFsMaximumInformation
 204 } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
 205
 206 typedef enum _SECTION_INHERIT
 207 {
 208         ViewShare = 1,
 209         ViewUnmap = 2
 210
 211 } SECTION_INHERIT;
 212
 213 /*      object information */
 214
 215 typedef enum _OBJECT_INFORMATION_CLASS
 216 {
 217         DunnoTheConstants1
 218
 219 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
 220
 221
 222 /*      system information */
 223
 224 typedef enum SYSTEM_INFORMATION_CLASS
 225 {       Unknown1 = 1,
 226         Unknown2,
 227         Unknown3,
 228         Unknown4,
 229         SystemPerformanceInformation
 230 } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
 231
 232 /* reading coffee grounds... */
 233 typedef struct _THREAD_INFO
 234 {       DWORD   Unknown1[6];
 235         DWORD   ThreadID;
 236         DWORD   Unknown2[3];
 237         DWORD   Status;
 238         DWORD   WaitReason;
 239         DWORD   Unknown3[4];
 240 } THREAD_INFO, PTHREAD_INFO;
 241
 242 typedef struct _VM_COUNTERS_
 243 {       ULONG PeakVirtualSize;
 244         ULONG VirtualSize;
 245         ULONG PageFaultCount;
 246         ULONG PeakWorkingSetSize;
 247         ULONG WorkingSetSize;
 248         ULONG QuotaPeakPagedPoolUsage;
 249         ULONG QuotaPagedPoolUsage;
 250         ULONG QuotaPeakNonPagedPoolUsage;
 251         ULONG QuotaNonPagedPoolUsage;
 252         ULONG PagefileUsage;
 253         ULONG PeakPagefileUsage;
 254 } VM_COUNTERS, *PVM_COUNTERS;
 255
 256 /* process information */
 257
 258 typedef struct _PROCESS_INFO
 259 {       DWORD           Offset;         /* 00 offset to next PROCESS_INFO ok*/
 260         DWORD           ThreadCount;    /* 04 number of ThreadInfo member ok */
 261         DWORD           Unknown1[6];
 262         FILETIME        CreationTime;   /* 20 */
 263         DWORD           Unknown2[5];
 264         PWCHAR          ProcessName;    /* 3c ok */
 265         DWORD           BasePriority;
 266         DWORD           ProcessID;      /* 44 ok*/
 267         DWORD           ParentProcessID;
 268         DWORD           HandleCount;
 269         DWORD           Unknown3[2];    /* 50 */
 270         ULONG           PeakVirtualSize;
 271         ULONG           VirtualSize;
 272         ULONG           PageFaultCount;
 273         ULONG           PeakWorkingSetSize;
 274         ULONG           WorkingSetSize;
 275         ULONG           QuotaPeakPagedPoolUsage;
 276         ULONG           QuotaPagedPoolUsage;
 277         ULONG           QuotaPeakNonPagedPoolUsage;
 278         ULONG           QuotaNonPagedPoolUsage;
 279         ULONG           PagefileUsage;
 280         ULONG           PeakPagefileUsage;
 281         DWORD           PrivateBytes;
 282         DWORD           Unknown6[4];
 283         THREAD_INFO     ati[ANYSIZE_ARRAY];     /* 94 size=0x40*/
 284 } PROCESS_INFO, PPROCESS_INFO;
 285
 286 NTSTATUS WINAPI NtQuerySystemInformation(
 287         IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
 288         OUT PVOID SystemInformation,
 289         IN ULONG Length,
 290         OUT PULONG ResultLength);
 291
 292 /*
 293  *      system configuration
 294  */
 295
 296
 297 typedef struct _SYSTEM_TIME_ADJUSTMENT
 298 {
 299         ULONG   TimeAdjustment;
 300         BOOLEAN TimeAdjustmentDisabled;
 301
 302 } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
 303
 304 typedef struct _SYSTEM_CONFIGURATION_INFO
 305 {
 306         union
 307         { ULONG OemId;
 308           struct
 309           { WORD        ProcessorArchitecture;
 310             WORD        Reserved;
 311           } tag1;
 312         } tag2;
 313         ULONG   PageSize;
 314         PVOID   MinimumApplicationAddress;
 315         PVOID   MaximumApplicationAddress;
 316         ULONG   ActiveProcessorMask;
 317         ULONG   NumberOfProcessors;
 318         ULONG   ProcessorType;
 319         ULONG   AllocationGranularity;
 320         WORD    ProcessorLevel;
 321         WORD    ProcessorRevision;
 322
 323 } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
 324
 325
 326 typedef struct _SYSTEM_CACHE_INFORMATION
 327 {
 328         ULONG   CurrentSize;
 329         ULONG   PeakSize;
 330         ULONG   PageFaultCount;
 331         ULONG   MinimumWorkingSet;
 332         ULONG   MaximumWorkingSet;
 333         ULONG   Unused[4];
 334
 335 } SYSTEM_CACHE_INFORMATION;
 336
 337 /*
 338  *      NtQueryProcessInformation
 339  */
 340
 341 /* parameter ProcessInformationClass */
 342
 343 typedef enum _PROCESSINFOCLASS
 344 {       ProcessBasicInformation,
 345         ProcessQuotaLimits,
 346         ProcessIoCounters,
 347         ProcessVmCounters,
 348         ProcessTimes,
 349         ProcessBasePriority,
 350         ProcessRaisePriority,
 351         ProcessDebugPort,
 352         ProcessExceptionPort,
 353         ProcessAccessToken,
 354         ProcessLdtInformation,
 355         ProcessLdtSize,
 356         ProcessDefaultHardErrorMode,
 357         ProcessIoPortHandlers,
 358         ProcessPooledUsageAndLimits,
 359         ProcessWorkingSetWatch,
 360         ProcessUserModeIOPL,
 361         ProcessEnableAlignmentFaultFixup,
 362         ProcessPriorityClass,
 363         ProcessWx86Information,
 364         ProcessHandleCount,
 365         ProcessAffinityMask,
 366         ProcessPriorityBoost,
 367         ProcessDeviceMap,
 368         ProcessSessionInformation,
 369         ProcessForegroundInformation,
 370         ProcessWow64Information,
 371         MaxProcessInfoClass
 372 } PROCESSINFOCLASS;
 373
 374 /* parameter ProcessInformation (depending on ProcessInformationClass) */
 375
 376 typedef struct _PROCESS_BASIC_INFORMATION
 377 {       DWORD   ExitStatus;
 378         DWORD   PebBaseAddress;
 379         DWORD   AffinityMask;
 380         DWORD   BasePriority;
 381         ULONG   UniqueProcessId;
 382         ULONG   InheritedFromUniqueProcessId;
 383 } PROCESS_BASIC_INFORMATION;
 384
 385 NTSTATUS WINAPI NtQueryInformationProcess(
 386         IN HANDLE ProcessHandle,
 387         IN PROCESSINFOCLASS ProcessInformationClass,
 388         OUT PVOID ProcessInformation,
 389         IN ULONG ProcessInformationLength,
 390         OUT PULONG ReturnLength);
 391
 392 #define NtCurrentProcess() ( (HANDLE) -1 )
 393
 394 /*
 395  *      timer
 396  */
 397
 398 typedef enum _TIMER_TYPE
 399 {
 400         NotificationTimer,
 401         SynchronizationTimer
 402
 403 } TIMER_TYPE;
 404
 405 /*      token functions */
 406
 407 NTSTATUS WINAPI NtOpenProcessToken(
 408         HANDLE ProcessHandle,
 409         DWORD DesiredAccess,
 410         HANDLE *TokenHandle);
 411
 412 NTSTATUS WINAPI NtOpenThreadToken(
 413         HANDLE ThreadHandle,
 414         DWORD DesiredAccess,
 415         BOOLEAN OpenAsSelf,
 416         HANDLE *TokenHandle);
 417
 418 NTSTATUS WINAPI NtAdjustPrivilegesToken(
 419         IN HANDLE TokenHandle,
 420         IN BOOLEAN DisableAllPrivileges,
 421         IN PTOKEN_PRIVILEGES NewState,
 422         IN DWORD BufferLength,
 423         OUT PTOKEN_PRIVILEGES PreviousState,
 424         OUT PDWORD ReturnLength);
 425
 426 NTSTATUS WINAPI NtQueryInformationToken(
 427         HANDLE token,
 428         DWORD tokeninfoclass,
 429         LPVOID tokeninfo,
 430         DWORD tokeninfolength,
 431         LPDWORD retlen );
 432
 433 /*      sid functions */
 434
 435 BOOLEAN WINAPI RtlAllocateAndInitializeSid (
 436         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 437         BYTE nSubAuthorityCount,
 438         DWORD nSubAuthority0, DWORD nSubAuthority1,
 439         DWORD nSubAuthority2, DWORD nSubAuthority3,
 440         DWORD nSubAuthority4, DWORD nSubAuthority5,
 441         DWORD nSubAuthority6, DWORD nSubAuthority7,
 442         PSID *pSid );
 443
 444 BOOL WINAPI RtlInitializeSid(
 445         PSID pSid,
 446         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 447         BYTE nSubAuthorityCount);
 448
 449 DWORD WINAPI RtlFreeSid(
 450         PSID pSid);
 451
 452 BOOL WINAPI RtlEqualSid(
 453         PSID pSid1,
 454         PSID pSid2 );
 455
 456 DWORD WINAPI RtlLengthRequiredSid(
 457         DWORD nrofsubauths);
 458
 459 DWORD WINAPI RtlLengthSid(
 460         PSID sid);
 461
 462 LPDWORD WINAPI RtlSubAuthoritySid(
 463         PSID PSID,
 464         DWORD nr);
 465
 466 LPBYTE WINAPI RtlSubAuthorityCountSid(
 467         PSID pSid);
 468
 469 DWORD WINAPI RtlCopySid(
 470         DWORD len,
 471         PSID to,
 472         PSID from);
 473
 474 BOOL WINAPI RtlValidSid(
 475         PSID pSid);
 476
 477 BOOL WINAPI RtlEqualPrefixSid(
 478         PSID pSid1,
 479         PSID pSid2);
 480
 481 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(
 482         PSID pSid );
 483
 484 /*      security descriptor functions */
 485
 486 NTSTATUS WINAPI RtlCreateSecurityDescriptor(
 487         PSECURITY_DESCRIPTOR lpsd,
 488         DWORD rev);
 489
 490 NTSTATUS WINAPI RtlValidSecurityDescriptor(
 491         PSECURITY_DESCRIPTOR SecurityDescriptor);
 492
 493 ULONG WINAPI RtlLengthSecurityDescriptor(
 494         PSECURITY_DESCRIPTOR SecurityDescriptor);
 495
 496 NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
 497         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 498         OUT PBOOLEAN lpbDaclPresent,
 499         OUT PACL *pDacl,
 500         OUT PBOOLEAN lpbDaclDefaulted);
 501
 502 NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
 503         PSECURITY_DESCRIPTOR lpsd,
 504         BOOLEAN daclpresent,
 505         PACL dacl,
 506         BOOLEAN dacldefaulted );
 507
 508 NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
 509         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 510         OUT PBOOLEAN lpbSaclPresent,
 511         OUT PACL *pSacl,
 512         OUT PBOOLEAN lpbSaclDefaulted);
 513
 514 NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
 515         PSECURITY_DESCRIPTOR lpsd,
 516         BOOLEAN saclpresent,
 517         PACL sacl,
 518         BOOLEAN sacldefaulted);
 519
 520 NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
 521         PSECURITY_DESCRIPTOR SecurityDescriptor,
 522         PSID *Owner,
 523         PBOOLEAN OwnerDefaulted);
 524
 525 NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
 526         PSECURITY_DESCRIPTOR lpsd,
 527         PSID owner,
 528         BOOLEAN ownerdefaulted);
 529
 530 NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
 531         PSECURITY_DESCRIPTOR lpsd,
 532         PSID group,
 533         BOOLEAN groupdefaulted);
 534
 535 NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
 536         PSECURITY_DESCRIPTOR SecurityDescriptor,
 537         PSID *Group,
 538         PBOOLEAN GroupDefaulted);
 539
 540 NTSTATUS WINAPI RtlMakeSelfRelativeSD(
 541         IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
 542         IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
 543         IN OUT LPDWORD lpdwBufferLength);
 544
 545 NTSTATUS WINAPI RtlGetControlSecurityDescriptor(
 546         PSECURITY_DESCRIPTOR  pSecurityDescriptor,
 547         PSECURITY_DESCRIPTOR_CONTROL pControl,
 548         LPDWORD lpdwRevision);
 549
 550 /*      acl functions */
 551
 552 NTSTATUS WINAPI RtlCreateAcl(
 553         PACL acl,
 554         DWORD size,
 555         DWORD rev);
 556
 557 BOOLEAN WINAPI RtlFirstFreeAce(
 558         PACL acl,
 559         PACE_HEADER *x);
 560
 561 NTSTATUS WINAPI RtlAddAce(
 562         PACL acl,
 563         DWORD rev,
 564         DWORD xnrofaces,
 565         PACE_HEADER acestart,
 566         DWORD acelen);
 567
 568 BOOL WINAPI RtlAddAccessAllowedAce(
 569         IN OUT PACL pAcl,
 570         IN DWORD dwAceRevision,
 571         IN DWORD AccessMask,
 572         IN PSID pSid);
 573
 574 BOOL WINAPI AddAccessAllowedAceEx(
 575         IN OUT PACL pAcl,
 576         IN DWORD dwAceRevision,
 577         IN DWORD AceFlags,
 578         IN DWORD AccessMask,
 579         IN PSID pSid);
 580
 581 DWORD WINAPI RtlGetAce(
 582         PACL pAcl,
 583         DWORD dwAceIndex,
 584         LPVOID *pAce );
 585
 586 /*      string functions */
 587
 588 DWORD       WINAPI RtlAnsiStringToUnicodeSize(PSTRING);
 589 NTSTATUS    WINAPI RtlAnsiStringToUnicodeString(UNICODE_STRING*,const STRING *,BOOLEAN);
 590 NTSTATUS    WINAPI RtlAppendAsciizToString(STRING*,LPCSTR);
 591 NTSTATUS    WINAPI RtlAppendStringToString(STRING*,const STRING*);
 592 NTSTATUS    WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING*,const UNICODE_STRING*);
 593 NTSTATUS    WINAPI RtlAppendUnicodeToString(UNICODE_STRING*,LPCWSTR);
 594 LONG        WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
 595 LONG        WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 596 void        WINAPI RtlCopyString(STRING*,const STRING*);
 597 void        WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
 598 BOOLEAN     WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
 599 BOOLEAN     WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
 600 void        WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
 601 BOOLEAN     WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
 602 BOOLEAN     WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 603 void        WINAPI RtlFreeAnsiString(PSTRING);
 604 void        WINAPI RtlFreeOemString(PSTRING);
 605 void        WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
 606 void        WINAPI RtlInitAnsiString(PSTRING,LPCSTR);
 607 void        WINAPI RtlInitString(PSTRING,LPCSTR);
 608 void        WINAPI RtlInitUnicodeString(PUNICODE_STRING,LPCWSTR);
 609 NTSTATUS    WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
 610 NTSTATUS    WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
 611 UINT        WINAPI RtlOemStringToUnicodeSize(PSTRING);
 612 NTSTATUS    WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
 613 NTSTATUS    WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
 614 BOOLEAN     WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
 615 BOOLEAN     WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
 616 DWORD       WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
 617 NTSTATUS    WINAPI RtlUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
 618 DWORD       WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
 619 NTSTATUS    WINAPI RtlUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
 620 NTSTATUS    WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 621 NTSTATUS    WINAPI RtlUnicodeToMultiByteSize(DWORD*,LPCWSTR,UINT);
 622 NTSTATUS    WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 623 NTSTATUS    WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
 624 NTSTATUS    WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
 625 NTSTATUS    WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
 626 NTSTATUS    WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 627 NTSTATUS    WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
 628
 629 DWORD WINAPI RtlIsTextUnicode(
 630         LPVOID buf,
 631         DWORD len,
 632         DWORD *pf);
 633
 634 INT __cdecl wcstol(LPCWSTR,LPWSTR*,INT);
 635
 636 /*      resource functions */
 637
 638 typedef struct _RTL_RWLOCK {
 639         CRITICAL_SECTION        rtlCS;
 640         HANDLE          hSharedReleaseSemaphore;
 641         UINT                    uSharedWaiters;
 642         HANDLE          hExclusiveReleaseSemaphore;
 643         UINT                    uExclusiveWaiters;
 644         INT                     iNumberActive;
 645         HANDLE          hOwningThreadId;
 646         DWORD                   dwTimeoutBoost;
 647         PVOID                   pDebugInfo;
 648 } RTL_RWLOCK, *LPRTL_RWLOCK;
 649
 650 VOID   WINAPI RtlInitializeResource(
 651         LPRTL_RWLOCK);
 652
 653 VOID   WINAPI RtlDeleteResource(
 654         LPRTL_RWLOCK);
 655
 656 BYTE   WINAPI RtlAcquireResourceExclusive(
 657         LPRTL_RWLOCK, BYTE fWait);
 658
 659 BYTE   WINAPI RtlAcquireResourceShared(
 660         LPRTL_RWLOCK, BYTE fWait);
 661
 662 VOID   WINAPI RtlReleaseResource(
 663         LPRTL_RWLOCK);
 664
 665 VOID   WINAPI RtlDumpResource(
 666         LPRTL_RWLOCK);
 667
 668 /*      time functions */
 669
 670 typedef struct _TIME_FIELDS
 671 {   CSHORT Year;
 672     CSHORT Month;
 673     CSHORT Day;
 674     CSHORT Hour;
 675     CSHORT Minute;
 676     CSHORT Second;
 677     CSHORT Milliseconds;
 678     CSHORT Weekday;
 679 } TIME_FIELDS;
 680
 681 typedef TIME_FIELDS *PTIME_FIELDS;
 682
 683 VOID WINAPI RtlSystemTimeToLocalTime(
 684         IN  PLARGE_INTEGER SystemTime,
 685         OUT PLARGE_INTEGER LocalTime);
 686
 687 VOID WINAPI RtlTimeToTimeFields(
 688         PLARGE_INTEGER liTime,
 689         PTIME_FIELDS TimeFields);
 690
 691 BOOLEAN WINAPI RtlTimeFieldsToTime(
 692         PTIME_FIELDS tfTimeFields,
 693         PLARGE_INTEGER Time);
 694
 695 VOID WINAPI RtlTimeToElapsedTimeFields(
 696         PLARGE_INTEGER liTime,
 697         PTIME_FIELDS TimeFields);
 698
 699 void    WINAPI NtQuerySystemTime( LARGE_INTEGER *time );
 700
 701 BOOLEAN WINAPI RtlTimeToSecondsSince1980( const FILETIME *time, LPDWORD res );
 702 BOOLEAN WINAPI RtlTimeToSecondsSince1970( const FILETIME *time, LPDWORD res );
 703 void    WINAPI RtlSecondsSince1970ToTime( DWORD time, FILETIME *res );
 704 void    WINAPI RtlSecondsSince1980ToTime( DWORD time, FILETIME *res );
 705
 706 /*      heap functions */
 707
 708 /* Data structure for heap definition. This includes various
 709    sizing parameters and callback routines, which, if left NULL,
 710    result in default behavior */
 711
 712 typedef struct
 713 {       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
 714         ULONG   Unknown[11];
 715 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 716
 717 HANDLE WINAPI RtlCreateHeap(
 718         ULONG Flags,
 719         PVOID BaseAddress,
 720         ULONG SizeToReserve,
 721         ULONG SizeToCommit,
 722         PVOID Unknown,
 723         PRTL_HEAP_DEFINITION Definition);
 724
 725 PVOID WINAPI RtlAllocateHeap(
 726         HANDLE Heap,
 727         ULONG Flags,
 728         ULONG Size);
 729
 730
 731 BOOLEAN WINAPI RtlFreeHeap(
 732         HANDLE Heap,
 733         ULONG Flags,
 734         PVOID Address);
 735
 736 /*      exception */
 737
 738 void WINAPI NtRaiseException(
 739         PEXCEPTION_RECORD,PCONTEXT,BOOL);
 740
 741 void WINAPI RtlRaiseException(
 742         PEXCEPTION_RECORD);
 743
 744 void WINAPI RtlRaiseStatus(
 745         NTSTATUS);
 746
 747 void WINAPI RtlUnwind(
 748         PEXCEPTION_FRAME,
 749         LPVOID,
 750         PEXCEPTION_RECORD,DWORD);
 751
 752 /*      process environment block  */
 753 VOID WINAPI RtlAcquirePebLock(void);
 754 VOID WINAPI RtlReleasePebLock(void);
 755
 756 /*      mathematics */
 757 LONGLONG  WINAPI RtlConvertLongToLargeInteger( LONG a );
 758 LONGLONG  WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
 759 LONGLONG  WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
 760 LONGLONG  WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
 761 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
 762 LONGLONG  WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
 763 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
 764 LONGLONG  WINAPI RtlLargeIntegerNegate( LONGLONG a );
 765 LONGLONG  WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
 766 LONGLONG  WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
 767 LONGLONG  WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
 768 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
 769 UINT      WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
 770 ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
 771 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
 772
 773 /*      environment */
 774 DWORD WINAPI RtlCreateEnvironment(
 775         DWORD x1,
 776         DWORD x2);
 777
 778 DWORD WINAPI RtlDestroyEnvironment(
 779         DWORD x);
 780
 781 DWORD WINAPI RtlQueryEnvironmentVariable_U(
 782         DWORD x1,
 783         PUNICODE_STRING key,
 784         PUNICODE_STRING val) ;
 785
 786 DWORD WINAPI RtlSetEnvironmentVariable(
 787         DWORD x1,
 788         PUNICODE_STRING key,
 789         PUNICODE_STRING val);
 790
 791 /*      object security */
 792
 793 DWORD WINAPI RtlNewSecurityObject(
 794         DWORD x1,
 795         DWORD x2,
 796         DWORD x3,
 797         DWORD x4,
 798         DWORD x5,
 799         DWORD x6);
 800
 801 DWORD WINAPI RtlDeleteSecurityObject(
 802         DWORD x1);
 803
 804 NTSTATUS WINAPI
 805 NtQuerySecurityObject(
 806         IN HANDLE Object,
 807         IN SECURITY_INFORMATION RequestedInformation,
 808         OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
 809         IN ULONG Length,
 810         OUT PULONG ResultLength);
 811
 812 NTSTATUS WINAPI
 813 NtSetSecurityObject(
 814         IN HANDLE Handle,
 815         IN SECURITY_INFORMATION SecurityInformation,
 816         IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 817
 818 /*      registry functions */
 819
 820 NTSTATUS    WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
 821                                const UNICODE_STRING*,ULONG,PULONG);
 822 NTSTATUS    WINAPI NtDeleteKey(HANDLE);
 823 NTSTATUS    WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
 824 NTSTATUS    WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 825 NTSTATUS    WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
 826 NTSTATUS    WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
 827 NTSTATUS    WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
 828 NTSTATUS    WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
 829                                    void*,DWORD,DWORD*);
 830 NTSTATUS    WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
 831
 832
 833 NTSTATUS WINAPI NtEnumerateValueKey(
 834         HANDLE KeyHandle,
 835         ULONG Index,
 836         KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
 837         PVOID KeyInformation,
 838         ULONG Length,
 839         PULONG ResultLength);
 840
 841 NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
 842
 843 NTSTATUS WINAPI NtNotifyChangeKey(
 844         IN HANDLE KeyHandle,
 845         IN HANDLE Event,
 846         IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
 847         IN PVOID ApcContext OPTIONAL,
 848         OUT PIO_STATUS_BLOCK IoStatusBlock,
 849         IN ULONG CompletionFilter,
 850         IN BOOLEAN Asynchroneous,
 851         OUT PVOID ChangeBuffer,
 852         IN ULONG Length,
 853         IN BOOLEAN WatchSubtree);
 854
 855 NTSTATUS WINAPI NtQueryMultipleValueKey(
 856         HANDLE KeyHandle,
 857         PVALENTW ListOfValuesToQuery,
 858         ULONG NumberOfItems,
 859         PVOID MultipleValueInformation,
 860         ULONG Length,
 861         PULONG  ReturnLength);
 862
 863 NTSTATUS WINAPI NtReplaceKey(
 864         IN POBJECT_ATTRIBUTES ObjectAttributes,
 865         IN HANDLE Key,
 866         IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
 867
 868 NTSTATUS WINAPI NtRestoreKey(
 869         HANDLE KeyHandle,
 870         HANDLE FileHandle,
 871         ULONG RestoreFlags);
 872
 873 NTSTATUS WINAPI NtSaveKey(
 874         IN HANDLE KeyHandle,
 875         IN HANDLE FileHandle);
 876
 877 NTSTATUS WINAPI NtSetInformationKey(
 878         IN HANDLE KeyHandle,
 879         IN const int KeyInformationClass,
 880         IN PVOID KeyInformation,
 881         IN ULONG KeyInformationLength);
 882
 883 NTSTATUS WINAPI NtUnloadKey(
 884         IN HANDLE KeyHandle);
 885
 886 NTSTATUS WINAPI NtClose(
 887         HANDLE Handle);
 888
 889 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
 890 NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
 891
 892 NTSTATUS WINAPI NtClearEvent(HANDLE);
 893 NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
 894 NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
 895 NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
 896 NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
 897 NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
 898 NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
 899 NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
 900
 901 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
 902 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
 903 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
 904 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
 905 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
 906 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
 907 BOOL     WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
 908 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
 909
 910 /* string functions */
 911 extern LPSTR _strlwr( LPSTR str );
 912 extern LPSTR _strupr( LPSTR str );
 913
 914 /*      misc */
 915
 916 #if defined(__i386__) && defined(__GNUC__)
 917 static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
 918 static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
 919 #else  /* __i386__ && __GNUC__ */
 920 void WINAPI DbgBreakPoint(void);
 921 void WINAPI DbgUserBreakPoint(void);
 922 #endif  /* __i386__ && __GNUC__ */
 923 void WINAPIV DbgPrint(LPCSTR fmt, ...);
 924
 925 DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
 926 DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
 927 LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
 928 DWORD WINAPI RtlNtStatusToDosError(DWORD error);
 929 BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
 930 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
 931
 932 DWORD WINAPI RtlOpenCurrentUser(
 933         IN ACCESS_MASK DesiredAccess,
 934         OUT PHANDLE KeyHandle);
 935
 936 BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
 937 BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
 938
 939 NTSTATUS WINAPI
 940 NtAccessCheck(
 941         IN PSECURITY_DESCRIPTOR SecurityDescriptor,
 942         IN HANDLE ClientToken,
 943         IN ACCESS_MASK DesiredAccess,
 944         IN PGENERIC_MAPPING GenericMapping,
 945         OUT PPRIVILEGE_SET PrivilegeSet,
 946         OUT PULONG ReturnLength,
 947         OUT PULONG GrantedAccess,
 948         OUT PBOOLEAN AccessStatus);
 949
 950 #ifdef __cplusplus
 951 }
 952 #endif
 953
 954 #include "poppack.h"
 955
 956 #endif